Desarrollando en Cobol y Natural sobre Plataforma Mainframe

miércoles, 31 de julio de 2013

Comprimir Libreria de Objetos en ISPF

Uno de los problemas típicos con los que se encuentra el desarrollador de Cobol es el consistente en el llenado de alguna de sus librerías de Objetos. Cuando esto ocurre, al intentar realizar un SAVE sobre cualquier objeto contenido en ella se obtiene un error de SYSTEM ABEND '0E37'.

IEC032I E37-04,IFG0554P,IBMUSER,DBSPROC,ISP11417,0A80,ZARES1,LIBPR.FUENTES.JJ00
***  
                                                                      

Para solucionar este problema, podemos realizar 3 posibles actuaciones sobre nuestra librería:

1) Comprimir el contenido de la librería, liberando espacio de la misma.

2) Ampliar el espacio de la librería.

3) Ampliar los bloques del directorio.

En el post que nos ocupa vamos a indicar cómo se puede acometer la primera solución propuesta, esto es, la compresión del contenido de la misma.

Una librería se puede comprimir de dos formas diferentes:

A) Opción 3.1 del ISPF

Se accede a la opción 3 del ISPF.

3  Utilities     Perform utility functions        

Y, a continuación, a la opción 1.

1  Library     Compress or print data set.  Print index listing.  Print, rename, delete, browse, edit or view members        

En la pantalla accedida se inserta el comando "C" en la línea "Option" y en el apartado "ISPF Library" se introduce el nombre de la librería que deseamos comprimir.



Tras pulsar INTRO, si todo ha ido correctamente se mostrará el mensaje:

Compress successful

B) Opción 3.4 del ISPF

Se accede a la opción 3 del ISPF.

3  Utilities     Perform utility functions        

Y, a continuación, a la opción 4.

4  Dslist      Print or display (to process) list of data set names. Print or display VTOC information               

Posteriormente, indicamos las librerías que queremos que se visualicen en la línea "Dsname Level". Por ejemplo, en nuestro caso introduciremos LIBPR*.

Enter one or both of the parameters below:
   Dsname Level . . . LIBPR*             
   Volume serial  . .                   


En la pantalla mostrada, introducimos el comando "Z" a la izquierda de la librería que deseamos comprimir.



Tras la ejecución, si todo ha ido bien, se mostrará el mensaje:

Compress successful

Tras realizar esta acción, ya no deberíamos tener problemas a la hora de almacenar más información en nuestra librería. Si, a pesar de ello, continuamos teniendo problemas de espacio, entonces no nos quedará más remedio que recurrir a las soluciones 2º ó 3º mencionadas más arriba (Ampliar el espacio de la librería o Ampliar los bloques del directorio). Pero esto ya lo veremos en un post aparte.

Saludos.

lunes, 29 de julio de 2013

Modificar un Registro en una Tabla DB2

Para actualizar un registro en una Tabla DB2 hay que recurrir a la sentencia UPDATE de SQL. Este comando nos permite actuar con precisión y elegir los datos que deseamos que sean modificados en el registro elegido, sin que por ello tengan que verse afectados el resto de campos.

 

UPDATE JJCLIEM0 
  SET (OBSERVACIONES,FECHA) =
  ('FINAL',CURRENT TIMESTAMP)              
  WHERE CLIENTE = 10;                                     
        

Para la correcta ejecución de esta sentencia tendremos que incluir el comando UPDATE seguido por el nombre de la tabla afectada.

UPDATE JJCLIEM0 

A continuación, se incluirá la cláusula SET seguida por el nombre de los campos (entre paréntesis) que van a ser modificados.

  SET (OBSERVACIONES,FECHA) = 

Posteriormente, se indicarán (entre paréntesis) los valores con los que van a ser actualizados los campos indicados anteriormente.

  ('FINAL',CURRENT TIMESTAMP)  

Finalmente, tendremos que añadir la cláusula WHERE para indicarle a la sentencia cuál (o cuales) es el registro que se va a ver afectado por el cambio indicado más arriba.

  WHERE CLIENTE = 10;

Una vez terminada la ejecución, la consulta realizada en QMF nos arrojará el registro con los nuevos valores indicados. En el ejemplo anterior vemos que ya aparece el valor "FINAL" en el campo OBSERVACIONES. 

OBSERVACIONES FECHA                    
------------- -------------------------

INICIAL       2013-07-24-10.50.22.2171

-             2013-07-25-10.22.26.4672

-             2013-07-25-10.43.08.6969

FINAL         2013-07-25-11.12.17.5948 

Por último, puntualizar que si únicamente quisiéramos actualizar un campo del registro, entonces no sería necesaria la inclusión de los paréntesis en la sentencia. La cosa quedaría así, por ejemplo:

UPDATE JJCLIEM0 SET OBSERVACIONES = 'FINAL'
  WHERE CLIENTE = 10;   
                   

Saludos.


domingo, 28 de julio de 2013

Insertar Registro en Tabla DB2

Para insertar registros nuevos en una tabla DB2, bastará con recurrir a la conocida sentencia INSERT de SQL. Nos bastará con realizar la ejecución del comando en la herramienta QMF y así nos quedará dado de alta el nuevo registro en el Fichero seleccionado.

 

INSERT INTO JJCLIEM0 
(CLIENTE,
NOMBRE,
APELLIDO1,
APELLIDO2,
ALTURA,
PESO,
IMC,
FECHA)
VALUES 
(3,
'MARINA',
'GUTIERREZ',
'ARAGON',
1.60,
60.00,
23.43,
CURRENT TIMESTAMP);

Para ejecutar correctamente la sentencia, en primer lugar tendremos que incluir el comando INSERT INTO seguido del nombre de la Tabla en la que queremos insertar el registro.

INSERT INTO JJCLIEM0 

A continuación tendremos que enumerar, entre paréntesis, todos los campos para los que vamos a insertar algún dato en el nuevo registro a crear.

(CLIENTE,

Después incluiremos la cláusula VALUES y, finalmente, entre paréntesis, los valores asociados (para el registro afectado) a cada uno de los campos mencionados previamente.

VALUES 
(3,

Tras la ejecución de la sentencia INSERT, el registro debería quedar dado de alta en la Tabla DB2. En el ejemplo anterior, la SELECT de SQL nos arrojaría el nuevo registro creado.

        CLIENTE  NOMBRE                APELLIDO1          
  -------------  --------------------  --------------------
              1  JOSE JAVIER           SANCHEZ            
              2  FREDDIE               SANCHEZ            
              3  MARINA                GUTIERREZ          
                                                          
                                                          
*** END ***              
                                                                               

Saludos.

sábado, 27 de julio de 2013

Modificar formato de Campo de una Tabla DB2

En el caso de que necesitemos modificar el formato de un campo de una Tabla DB2 (ya sea por causa de un error o porque se han modificado los requisitos funcionales), existe una instrucción que nos permite realizar dicha tarea con bastante facilidad.

ALTER TABLE JJCLIEM0                           
  ALTER COLUMN PESO SET DATA TYPE NUMERIC(5,2);


Para ello, únicamente tendremos que entrar en la herramienta QMF del DB2I y emplear el comando ALTER para la tabla afectada. Esta sentencia permite modificar la estructura de una tabla DB2 sin más que indicar el nombre de la misma.

ALTER TABLE JJCLIEM0

Posteriormente, se precisará incluir la cláusula ALTER COLUM y el nombre del campo afectado por la modificación de formato que queremos llevar a cabo.

ALTER COLUMN PESO SET DATA TYPE NUMERIC(5,2)

Esta cláusula incluirá también el comando SET DATA TYPE y, a continuación, el nuevo formato que va a asumir el campo afectado. En el ejmplo, el campo "PESO" pasará a tener el formato NUMERIC (5,2).



Tras ejecutar la sentencia ALTER, una simple consulta SQL lanzada desde la herramienta QMF nos mostrará la tabla con el nuevo formato del campo modificado. El campo PESO tiene una longitud de 8 posiciones, correspondiente al formato Numeric(5,2).

  ALTURA      PESO       IMC
--------  --------  --------
    1.77     84.00     26.81


Saludos.

viernes, 26 de julio de 2013

Añadir nuevo Campo a una Tabla DB2

En ocasiones, en la definición inicial de una Tabla no quedan recogidos todos los campos que se van a necesitar en un futuro. Puede que haya sido un error en la arquitectura o que simplemente se haya decidido posteriormente que se precisa un dato adicional en determinado sitio.

ALTER TABLE JJCLIEM0       
ADD COLUMN FECHA TIMESTAMP;


En estos casos, para añadir el nuevo campo a la tabla podremos recurrir a la sentencia ALTER de SQL.  Este comando nos permite alterar la estructura de la tabla, ya sea para añadir o para eliminar una columna determinada.

ALTER TABLE JJCLIEM0



En particular, para crear un nuevo campo tendremos que incluir la cláusula ADD y, a continuación, indicar tanto el nombre de la columna como el formato asociado a la misma. Finalmente, podremos incluir (o no) la cláusula NOT NULL, según convenga.

ADD COLUMN FECHA TIMESTAMP
 
En el ejemplo indicado, tras ejecutar la sentencia ALTER, se puede comprobar en una consulta que ya queda dada de alta una nueva columna denominada FECHA (con formato TIMESTAMP). Además, en este caso incluso ya hemos insertado un valor para dicho campo en uno de los registros.

      CLIENTE FECHA                    
------------- --------------------------
            1 2013-07-24-10.50.22.217174


Saludos.

jueves, 25 de julio de 2013

Creación de una Tabla DB2

Para crear un tabla DB2 necesitamos recurrir al comando CREATE de SQL. Este comando nos permite crear una tabla desde cero, sin necesidad de acceder a herramientas adicionales. Esto hace que esta labor sea muy sencilla en el entorno CICS. 

CREATE TABLE JJCLIEM0                  
     (CLIENTE   NUMERIC(10)   NOT NULL,
      NOMBRE    CHAR(20)      NOT NULL,
      APELLIDO1 CHAR(20)      NOT NULL,
      APELLIDO2 CHAR(20),              
      ALTURA    NUMERIC(3,2)  NOT NULL,
      PESO      NUMERIC(3,2)  NOT NULL,
      IMC       NUMERIC(3,2)  NOT NULL,
      OBSERVACIONES CHAR(50),          
      PRIMARY KEY(CLIENTE)); 
       

Como vemos en el ejemplo, esta función se compone de varias partes. Vamos a verlas detalladamente a continuación.

1º) En primer lugar, en el comando CREATE tenemos que indicar el nombre de la tabla que va a ser creada (obviamente).

CREATE TABLE JJCLIEM0      

2º) A continuación, se enumerarán todos los campos que van a estar incluidos en la misma. Para cada campo se indicará el formato asociado. Por ejemplo:

NOMBRE    CHAR(20)      NOT NULL

3º) También se deberá indicar cuál es la clave principal de la tabla creada. Esto se establecerá con el subcomando PRIMARY KEY.

PRIMARY KEY(CLIENTE)

4º) Adicionalmente, al final se puede indicar el TABLESPACE en el que deseamos que se incluya la tabla que vamos a crear. Esto se realizará con el comando IN.

IN TSCLIE

Si, como en el ejemplo inicial, no se incluye esta cláusula IN al final, entonces la ejecución del comando CREATE creará automáticamente un TABLESPACE que albergará únicamente a la tabla creada (se tratará de un Tablespace unitario que no podrá contener más de una tabla).

Una vez ejecutada la función CREATE, nuestra tabla quedará dada de alta. El comando puede ser ejecutado, por ejemplo, mediante la herramienta QMF (Query Management Facility) del DB2I, que se encuentra en el ISPF de cualquier entorno CICS.



Tras crear nuestra tabla, podríamos acceder a los campos de la misma mediante un simple comando SELECT, indicando el nombre que le hemos asociado a la misma.

SELECT * FROM JJCLIEM0;

La ejecución de este SELECT nos mostrará un display con todos los registros y todos los campos de la tabla. En este caso, como acabamos de crear la tabla, no se muestra ningún registro; únicamente podemos ver la lista de los campos creados.

        CLIENTE  NOMBRE                APELLIDO1          
  -------------  --------------------  --------------------
                                                          
                                                          
*** END ***                                                                                                   

Como vemos, la creación de tablas DB2 en el entorno CICS no es una labor que exija demasiado trabajo, siempre y cuando, previamente, hayamos definido correctamente la arquitectura del fichero.

Saludos.

viernes, 19 de julio de 2013

Borrado de Fichero en JCL

En ocasiones, en un JCL necesitamos realizar el borrado de un fichero ya existente para poder volver a generarlo con nuevos datos calculados. Para realizar esta acción no basta con indicar el nombre del fichero con el comando DELETE, sino que debemos emplear una de las Utilidades MVS.

En particular, aquí hay que utilizar la utilidad IEFBR14, tal y como se hace en el ejemplo siguiente.

//* BORRADO DE FICHERO DE SALIDA                         
//BORRADO  EXEC PGM=IEFBR14                              
//DD001JJ  DD DSN=JJ00.JJ0002CL.SALIDA1,                 
//            DISP=(MOD,DELETE),UNIT=SYSDA,SPACE=(TRK,0)  


La utilidad IEFBR14 (Branch Register 14) sirve para catalogar ficheros en vacío, borrarlos, etc... utilizando, para ello, la sentencia DISP. Básicamente, con la ejecución de esta utilidad se entra a ejecutar el programa y, a continuación, se sale de él. Por tanto, realmente es una utilidad que no ejecuta ninguna acción.



Aunque no realice ninguna ejecución, su empleo es necesario en el paso de borrado de Fichero, ya que la Data Definition para los datos debe ir acompañada de un programa. Y, como no necesitamos realizar ninguna acción adicional, nos basta con incluir el programa (dummy) IEFBR14.

El paso de borrado debe tener:

1º) Sentencia EXEC: Donde se incluirá PGM=IEFBR14 para invocar a la utilidad indicada.

//BORRADO  EXEC PGM=IEFBR14    

2º) Comando DSN: Donde se detallará el nombre del fichero a borrar.

//DD001JJ  DD DSN=JJ00.JJ0002CL.SALIDA1, 

3º) Parámetro DISP: Sirve para indicar el estado inicial del fichero y el estado en el que queremos que quede una vez finalizado el proceso.

//            DISP=(MOD,DELETE),UNIT=SYSDA,SPACE=(TRK,0)  

4º) Parámetro UNIT: se utiliza para indicar al sistema que sitúe el fichero en un dispositivo específico (disco, cinta).

5º) Parámetro SPACE: para indicar el espacio ocupado por el fichero.

Saludos.

jueves, 18 de julio de 2013

Utilidad IEFBR14 para JCL

La Utilidad IEFBR14 (Branch Register 14) es una de las utilidades MVS de las que podemos beneficiarnos cuando estamos operando con Ficheros en un JCL. Estas utilidades son, básicamente, programas estándar que realizar funciones predefinidas por el Sistema Operativo.

La utilidad IEFBR14 (Branch Register 14) sirve para catalogar ficheros en vacío, borrarlos, etc... utilizando, para ello, la sentencia DISP. Básicamente, con la ejecución de esta utilidad se entra a ejecutar el programa y, a continuación, se sale de él. Por tanto, realmente es una utilidad que no ejecuta ninguna acción.



Aunque no realice ninguna ejecución, a veces su empleo es muy útil, sobre todo cuando queremos realizar acciones simples sobre Ficheros. En esos casos, como no necesitamos realizar ninguna acción adicional, nos basta con incluir el programa (dummy) IEFBR14 en el paso del JCL (recordemos que la Data Definition para los datos debe ir acompañada de un programa).

Casos típicos de uso:

Borrado de Fichero.

//* BORRADO DE FICHERO DE SALIDA                         
//BORRADO  EXEC PGM=IEFBR14                              
//DD001JJ  DD DSN=JJ00.JJ0002CL.SALIDA1,                 
//            DISP=(MOD,DELETE),UNIT=SYSDA,SPACE=(TRK,0)  


Se incluye la sentencia EXEC con PGM=IEFBR14. A continuación, el DSN con el nombre del fichero a borrar. Finalmente, en DISP se incorpora la información asociada al borrado.

Catalogación de un Fichero en vacío.

//* CATALOGACION EN VACIO
//VACIO01  EXEC PGM=IEFBR14
//DD002JJ  DD DSN=JJ00.JJ0002CL.SALIDA1,
//            DISP=(NEW,CATLG,DELETE),
//            SPACE=(TRK,(10,5),RLSE), 

//            UNIT=SYSDA,VOL=SER=ZARES1, 
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920)

Se incluye la sentencia EXEC con PGM=IEFBR14. A continuación, el DSN con el nombre del fichero a catalogar. Finalmente, se incluyen los parámetros necesarios para la creación de un nuevo fichero (DISP, SPACE, UNIT, VOL, RECFM, LRECL y BLKSIZE).

Saludos.

martes, 16 de julio de 2013

Cierre de Ficheros en programa Cobol

Una vez que hemos realizado todas las operaciones que queríamos ejecutar en un programa Cobol, siempre es importante proceder al cierre del Fichero con el que hemos estado trabajando. Hay que recordar este punto, ya que uno de los errores típicos consiste en dejar el fichero abierto.



Un ejemplo de rutina de cierre de fichero sería la siguiente:

******************************************************************
* 9999-CERRAR-FICHEROS                                           
******************************************************************
 9999-CERRAR-FICHEROS.                                           
*    CIERRE DE LOS FICHEROS DE ENTRADA Y SALIDA                  
*    ------------------------------------------                  
     CLOSE ENTRADA1                                              
           SALIDA1                                               
*                                                                
*    ESTABLECEMOS MARCA DE FICHERO CERRADO                       
     SET CLOSE-FILES         TO TRUE                             
*                                                                
*    CARGAMOS FILE STATUS DE ENTRADA EN VARIABLE ASOCIADA        
*    ----------------------------------------------------        
     MOVE FS-ENTRADA1        TO SW-FILE-STATUS                     

     MOVE LT-DESC-ERR-CLOSE  TO WS-DESCRIPCION           
*                                                        
*    GESTION DEL FILE STATUS                             
*    -----------------------                             
     PERFORM 9400-CONTROL-FS-FICHEROS                    
        THRU 9400-CONTROL-FS-FICHEROS-EXIT               
*                                                        
*    CARGAMOS FILE STATUS DE SALIDA EN VARIABLE ASOCIADA 
*    --------------------------------------------------- 
     MOVE FS-SALIDA1         TO SW-FILE-STATUS           
     MOVE LT-DESC-ERR-CLOSE  TO WS-DESCRIPCION           
*                                                        
*    GESTION DEL FILE STATUS                             
*    -----------------------                             
     PERFORM 9400-CONTROL-FS-FICHEROS                    
        THRU 9400-CONTROL-FS-FICHEROS-EXIT.              
*                                                        
 9999-CERRAR-FICHEROS-EXIT.                              
     EXIT.                 
                               


Los puntos clave de esta rutina serían:

1º) Sentencia CLOSE: Para ejecutar el cierre de los ficheros con los que hemos estado trabajando a lo largo del programa.

     CLOSE ENTRADA1   

2º) Recogida de la variable FILE STATUS: Para verificar si ha habido algún error al ejecutar el cierre del fichero utilizado.

     MOVE FS-ENTRADA1        TO SW-FILE-STATUS    

3º) Gestión del FILE STATUS: Aquí tenemos que mostrar los diferentes mensajes de error, en función de los resultados obtenidos con la ejecución de la sentencia CLOSE.

     PERFORM 9400-CONTROL-FS-FICHEROS                    
        THRU 9400-CONTROL-FS-FICHEROS-EXIT.  


Este proceso habría que repetirlo para cada uno de los ficheros que hemos empleado en el programa. De hecho, en el ejemplo vemos como se realiza tanto para el fichero ENTRADA1 como para el fichero SALIDA1.

Saludos.

sábado, 13 de julio de 2013

Definición de Unidades y Volúmenes en JCL

Cuando queremos crear un nuevo fichero secuencial en un JCL, algunos de los parámetros asociados que tenemos que especificar son UNIT y VOL. El primero hace referencia al dispositivo en el que se va a hacer el almacenamiento, mientras que en el segundo se debe indicar el nombre del volumen en el que se va a situar dicho fichero.

//SALJCL1  DD DSN=JJ00.JJ0002CL.SALIDA1,          
//            DISP=(NEW,CATLG,DELETE),            
//            SPACE=(TRK,(10,5),RLSE),            
//            UNIT=SYSDA,VOL=SER=ZARES1,          
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920)


UNIT

Aquí especificaremos el modelo de cinta o de disco donde se va a almacenar la información. 

UNIT = Nombre

//            UNIT=SYSDA,

Para que no tengamos que conocer la configuración exacta de cintas o discos de nuestro Mainframe, existen una serie de Unidades con nombre "Esotérico". Se trata de unidades con nomenclatura estándar, que no depende de la instalación.



El esotérico SYSDA (System Direct Access) indica que queremos que el fichero se almacene en Disco. Normalmente se trata de un espacio de almacenamiento temporal, ya que las empresas únicamente suelen liberarlo 1 ó 2 veces al año. Si no se especifica nada, el Volumen se asigna de forma aleatoria.

UNIT=SYSDA

VOL

Aquí es donde debemos especificar el nombre del Volumen (Volume Serial Number) en el cual deseamos que quede almacenado nuestro fichero. El nombre debe ser un alfanumérico de 6 caracteres.

VOL=SER=Nombre

//            UNIT=SYSDA,VOL=SER=ZARES1, 

El VOL no sólo identifica discos, sino también las cintas. De modo que si quisiéramos grabar en una cinta concreta el fichero, basta con poner el nombre de la cinta en cuestión y la unidad de cintas mostraría al operador un mensaje luminoso que le indicaría que debe montar la cinta con la etiqueta que le hemos asignado.

Saludos.

viernes, 12 de julio de 2013

Generación de Fichero de Salida en JCL

Para crear un fichero de salida en un paso de JCL, hemos de emplear una sentencia DD. El nombre asociado a la DD en el JCL debe coincidir con el nombre de fichero lógico definido en el comando SELECT del programa Cobol.

//SALJCL1  DD DSN=JJ00.JJ0002CL.SALIDA1,         
//            DISP=(NEW,CATLG,DELETE),           
//            SPACE=(TRK,(10,5),RLSE),           
//            UNIT=SYSDA,VOL=SER=ZARES1,         
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920)


En el ejemplo, SALJCL1 será también el nombre del fichero lógico en el programa Cobol. Estos son los parámetros principales del paso:

1) DSN: Nombre físico del fichero.

//SALJCL1  DD DSN=JJ00.JJ0002CL.SALIDA1,    

2) DISP: Sirve para indicar el estado inicial del fichero y el estado en el que queremos que quede una vez finalizado el proceso. Tiene 3 parámetros.

DISP=(Inicio,Final,Error)

//            DISP=(NEW,CATLG,DELETE),      

   Parámetro 1: es el estado inicial del fichero.
  • NEW: no existe y se crea en el paso.
  • OLD: existe y se debe utilizar de forma exclusiva.
  • SHR: existe y se puede compartir.
  • MOD: si el fichero ya existe, no se puede compartir, y se posiciona tras el último registro existente en el fichero.
    • Si el fichero no existe, equivale al estado NEW.
    • Si no se codifica, se asume por defecto NEW.
   Parámetro 2: estado del fichero tras una correcta ejecución del paso.

   Parámetro 3: estado en que queda el fichero si el paso se ejecuta de forma incorrecta (ABEND).
  • DELETE: el fichero se borra, incluso del catálogo.
  • KEEP: el fichero se guarda al terminar el paso. Sin embargo, no guarda información de fichero (UNIT, VOL...) para pasos posteriores, habría que volver a codificarlas al usar el fichero.
  • CATLG: el fichero se guarda y se cataloga.
  • UNCATLG: el fichero se guarda, pero se elimina del catálogo. 




3) VOL: volumen en el que se almacenará el fichero de salida, si se ha creado en el paso.

//            UNIT=SYSDA,VOL=SER=ZARES1,   

4) UNIT: se utiliza para indicar al sistema que sitúe el fichero en un dispositivo específico (disco, cinta).

5) SPACE: para indicar el espacio que requerirá un nuevo fichero. Consta de 4 parámetros.

SPACE=(Unidad,(Cantidad1,Cantidad2),Release) 

//            SPACE=(TRK,(10,5),RLSE),     
  • Unidad en las que se mide el espacio (pistas (TRK), cilindros (CYL)).
  • Cantidad de espacio a asignar:
    • Extensión primaria: espacio que se reservará para el fichero en el momento de crearlo.
    • Extensión secundaria: cantidad de espacio que se añade cada vez que el fichero se quede pequeño.
  • RLSE: indica que el espacio no utilizado en la creación del fichero, se liberará al cerrarlo

6) RECFM: Formato de los registros del fichero.

//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=27920)

7) LRECL: Longitud de los registros del fichero.

8) BLKSIZE: Tamaño de los bloques del fichero.

Saludos.

miércoles, 10 de julio de 2013

Universo Mainframe

Este blog nace por la necesidad de llevar un diario de toda la operativa que voy realizando en el universo mainframe con mi entorno CICS. Según he leído es de vital importancia llevar un registro de las acciones que se realizan, así como de las razones por las que se realizaron.

Más importante aún es analizar las razones por las que creemos que algo no ha salido tal y como esperábamos, sobre todo si ese problema aparece porque nos hemos saltado algún punto necesario en el proceso de desarrollo.

No es que hasta ahora me vaya mal con el Mainframe, pero es importante tener en cuenta que las cosas pueden llegar a olvidarse. Así que nunca vendrá mal tener un registro de cómo se solucionaron problemas anteriores, por si en algún momento del futuro hay que volver a consultarlos.



En cualquier entorno hay que ser cuidadoso con los procesos que seguimos en el desarrollo, hay que ser consistente y es entonces cuando se ve quiénes son los buenos desarrolladores y quiénes son los que únicamente estaban siguiendo la inercia de lo que alguien les ha contado.

Bueno, espero que este blog me ayude a depurar al máximo mi técnica.

Related Posts Plugin for WordPress, Blogger...