Desarrollando en Cobol y Natural sobre Plataforma Mainframe

jueves, 30 de octubre de 2014

Visualizar contenido de una tabla DB2 desde ISPF

Para aquellos a los que no les resulte del todo cómodo usar las herramientas SPUFI o QMF para acceder al contenido de las tablas DB2, existe una forma mucho más sencilla de visualizar o modificar el contenido de las mismas desde una opción del ISPF.

En el menú principal POM del ISPF (Primary Option Menu) hay disponible una opción, denominada FILE MANAGER DB2, que nos permite realizar distintas acciones sobre las tablas DB2. Entre estas operaciones, disponemos de la visualización y la edición del contenido de los registros de la tabla.



Para ver cómo se puede realizar la visualizacion del DB2, vamos a suponer que nos encontramos en el menú POM del ISPF.

Visualización del contenido de una tabla DB2

1º) Seleccionamos la opción 14 - File Mgr / DB2 - File Manager for DB2. De este modo, accedemos a las distintas opciones del File Manager DB2.

14 File Mgr/DB2  File Manager for DB2

2º) A continuación, desde el menú principal del File Manager DB2, seleccionamos la opción 1 - View - View DB2 Object. Esto nos permitirá acceder a la ventana de visualización.

1  View          View DB2 object

3º) En la pantalla de visualización tendremos que indicar el Owner y el nombre de la tabla DB2 que deseamos ver. Como Processing Option elegiremos la número 3 - Generate from table.



4º) Finalmente, accedemos a la ventana en la que se nos mostrarán los registros contenidos en la tabla DB2. Recordemos que estamos en modo visualización y, por tanto, no se puede modificar nada de la información mostrada.



Tal y como podemos ver en la imagen, esta opción nos muestra los datos almacenados en todos los campos de cada uno de los registros que hay dados de alta en el DB2.

Esta es una forma muy sencilla de visualizar el contenido de las tablas DB2. Por supuesto, ya sabemos que disponemos de las herramientas SPUFI o QMF para realizar esta acción pero, tal y como hemos podido observar, el FILE MANAGER DB2 también nos ofrece una cómoda alternativa de acceso a DB2.

Pues nada, esperamos que con esto os haya quedado clara la forma en la que podemos acceder al detalle de las tablas DB2 desde el propio ISPF.

Saludos.

jueves, 23 de octubre de 2014

Herramienta DCLGEN para generar Includes de DB2 (y 2)

Hace unas semanas comenzamos a ver cuáles eran los pasos a seguir para generar objetos DCL mediante la Herramienta DCLGEN (ver post Herramienta DCLGEN para generar Includes de Ficheros - 1). Hoy trataremos de ver qué es lo que tenemos que hacer para utilizar dichos objetos desde nuestros programas Cobol.

Tal y como estuvimos viendo, siguiendo el procedimiento indicado, la herramienta DCLGEN nos generaba un objeto en una librería de nuestra elección. Al final del anterior post llegamos a mostrar un ejemplo de cómo era el contenido de un objeto DCL que habíamos generado con el nombre SEQUIPOS.



Como se podía observar en dicho ejemplo, el código de un objeto DCL está dividido en 3 partes:

A) Estructura de la Tabla DB2. En esta primera parte nos aparece el nombre de la tabla DB2  y de las columnas que la componen. Estos son los nombres de columna que tendremos que usar en las sentencias SQL que usemos en nuestro programa Cobol.

B) Estructura de Variable Host. En esta segunda parte nos aparece la definición de todas las variables Host que podríamos utilizar en el programa Cobol. Básicamente, el DCLGEN habrá creado una variable Host equivalente a cada una de las columnas de la tabla DB2. La idea es que podamos usar cada una de estas variables de la agrupación DCLEQUIPOS para recoger la información de la columna de nombre análogo de la tabla DB2.

C) Estructura de Variables Indicador. En la tercera y última parte se habrán creado las Variables de Indicador Nulo asociadas a cada una de las variables Host que lo requieran. Se da de alta un array INDSTRUC cuyo tamaño será igual al número de columnas de la tabla DB2 (en el ejemplo, se crea un INDSTRUC de 5 ocurrencias debido a que la tabla EQUIPOS tiene 5 columnas).

Para que toda la estructura de datos creada está disponible desde Cobol, en el programa tendremos que incluir la correspondiente sentencia INCLUDE haciendo referencia al objeto DCL. En nuestro ejemplo, en la WORKING-STORAGE SECTION tendríamos que incluir tanto las del área de comunicaciones estándar SQLCA como las de nuestro objeto SEQUIPOS.

* INCLUDES DE LOS OBJETOS DCL
EXEC SQL      
  INCLUDE SQLCA
END-EXEC.

*      
EXEC SQL      
  INCLUDE SEQUIPOS
END-EXEC.     


Con la definición anterior, un ejemplo de cómo se codificaría, en un programa Cobol, una declaración SELECT contra la tabla EQUIPOS empleando el objeto DCL sería la siguiente. En primer lugar, ponemos la definición del Cursor de la tabla (que estaría en la WORKING-STORAGE SECTION) y, a continuación, la sentencia FETCH que carga la información en las variables Host (ubicada en la PROCEDURE DIVISION).

* CURSOR PARA POSICIONARSE EN LA TABLA EQUIPOS
EXEC SQL DECLARE EQUIPOS-C CURSOR FOR
  SELECT *                        
  FROM   EQUIPOS                    
  WHERE EQUINO = :ENO              
  ORDER BY EQUINAME               
END-EXEC.                           


...
...
...

* OBTENCION DE COLUMNAS DE REGISTRO DE LA TABLA EQUIPOS
EXEC SQL                       
         FETCH EQUIPOS-C        
         INTO                  
         :EQUINO,           
         :EQUINAME,           
         :ENTNO, 
         :EMPREQUI,              
         :CITYNAME
END-EXEC.
                       

Como vemos, en el FETCH se está haciendo referencia a las variables Host que aparecen en el objeto DCL definidas bajo la agrupación DCLEQUIPOS (en el DECLARE CURSOR que aparece justo encima, por contra, se hace referencia a los nombres de las columnas de la tabla DB2). Una vez recuperadas, ahora ya podremos trabajar normalmente con estas variables Host en el código de nuestro programa Cobol. Por ejemplo, podríamos hacer un DISPLAY así.

DISPLAY EQUINO EQUINAME ENTNO EMPREQUI CITYNAME

Como se puede observar, el empleo de la herramienta DCLGEN nos ahorra mucho trabajo a la hora de definir, en nuestros programas Cobol, las estructuras de las tablas DB2 y las estructuras de sus variables Host asociadas. Esto mismo se podría declarar de forma manual, pero es indudable que haciéndolo mediante la herramienta nos ahorraremos quebraderos de cabeza.

Siguiendo los pasos que se han ido indicando en el post, no deberíamos tener ningún problema con la generación de los objetos DCL a través de la herramienta DCLGEN. Quizás os parezca un poco complicado la primera vez, pero os podemos asegurar que enseguida dominaréis el procedimiento y que agradeceréis el tiempo economizado.

En principio, con todo lo comentado, por nuestra parte quedaría completado el tema de la herramienta DCLGEN. De todas formas, no dudéis en consultarnos cualquier duda que os surja respecto a ella, si lo consideráis oportuno.

Saludos.

jueves, 16 de octubre de 2014

Herramienta DCLGEN para generar Includes de DB2 (1)

Cuando estamos implementando un programa Cobol con acceso a DB2, una de las cosas que tenemos que incluir en el mismo es la declaración de las tablas DB2, junto con todos los campos que las componen, y la declaración de las variables auxiliares que vamos a emplear para recoger los registros de dichas tablas. El DCLGEN nos permitirá crear de forma automática toda esta estructura de datos.

La herramienta DCLGEN sirve para realizar la generación de objetos DCL. El DCL (Data Control Language) es la parte del lenguaje SQL destinada al control de los datos. Así que, dicho de otro modo, el DCLGEN nos permite realizar la generación de la parte del código SQL que contiene las variables necesarias para el tratamiento de las tablas DB2 desde los programas Cobol.

Obviamente, estas sentencias DCL también se podrían generar manualmente, pero siempre será más cómodo realizar la tarea mediante un generador automático como el DCLGEN. Una vez hayamos aprendido cómo se opera con él, lo más probable es que nunca dejemos de usarlo.



Los pasos a seguir para realizar la generación de un objeto con código DCL son los siguientes, suponiendo que nos encontramos en el menú principal POM (Primary Option Menu) del ISPF.

1º) Seleccionamos la opción 12 - Subsystems - DB/DC Subsystems. Se nos abrirá una ventana mostrando las diversas opciones disponibles.

12 Subsystems    DB/DC Subsystems 

2º) Opción D - DB2I: Seleccionamos la opción D - DB2I - Interactive Database 2. Así entraremos en el menú principal (POM) de la herramienta DB2I.

D  DB2I      Interactive Database 2   

3º) Opción 2 - DCLGEN: Seleccionamos la opción 2 - DCLGEN - Generate SQL and source language declarations.

2  DCLGEN      (Generate SQL and source language declarations)

4º) En el panel DCLGEN tendremos que introducir los parámetros requeridos para la generación del objeto DCL.

- SOURCE TABLE NAME: Aquí tendremos que introducir el nombre de la tabla para la cual deseamos que se genere su objeto DCL asociado. Por ejemplo, nosotros especificamos la tabla EQUIPOS.

1  SOURCE TABLE NAME ===> EQUIPOS

- TABLE OWNER: Aquí habrá que especificar el nombre del usuario propietario de la tabla.

2  TABLE OWNER ..... ===> SYSTEM1

- DATA SET NAME: En este campo se debe especificar el nombre (y la ubicación) del objeto DCL que va a generar la herramienta DCLGEN. Por ejemplo, nosotros queremos un objeto llamado SEQUIPOS que deberá crearse en la librería JJ00.FACTURAS.DCLGEN.DATA.

4  DATA SET NAME ... ===> 'JJ00.FACTURAS.DCLGEN.DATA(SEQUIPOS)'

- ACTION: Se provisionará el comando ADD si vamos a generar un nuevo objeto DCL o el comando REPLACE si se va a cambiar la estructura de un objeto ya existente.

6  ACTION .......... ===> REPLACE 

- INDICATOR VARS: Si queremos que nuestro objeto DCL incluya la declaración de las Variables de Indicador Nulo para los campos de la tabla que lo requieran, entonces tendremos que indicar YES en este parámetro.

12  INDICATOR VARS .. ===> YES

5º) Tras especificar todos los parámetros anteriores y pulsar INTRO, nos aparecerá un mensaje indicando que la generación se ha llevado a cabo correctamente.

DSNE904I EXECUTION COMPLETE, MEMBER SEQUIPOS REPLACED
***
  
                                               

A continuación, iríamos a la librería especificada en DATA SET NAME (en nuestro ejemplo, la JJ00.FACTURAS.DCLGEN.DATA) y podríamos verificar la existencia del nuevo objeto DCL generado.

Si nos asomamos al interior del objeto, veremos que su contenido tendrá un aspecto similar al siguiente:

******************************************************************
* DCLGEN TABLE(SYSTEM1.EQUIPOS)                                  *
*        LIBRARY(JJ00.FACTURAS.DCLGEN.DATA(SEQUIPOS))            *
*        LANGUAGE(COBOL)                                         *
*        QUOTE                                                   *
*        INDVAR(YES)                                             *
* ... IS THE DCLGEN COMMAND THAT MADE THE FOLLOWING STATEMENTS   *
******************************************************************
     EXEC SQL DECLARE EQUIPOS TABLE                     
     ( EQUINO                         CHAR(3) NOT NULL,          
       EQUINAME                       VARCHAR(36) NOT NULL,      
       ENTNO                          CHAR(6),                   
       EMPREQUI                       CHAR(3) NOT NULL,          
       CITYNAME                       VARCHAR(16)                
     ) END-EXEC.                                                 
******************************************************************
* COBOL DECLARATION FOR TABLE SYSTEM1.EQUIPOS                    *
******************************************************************
 01  DCLEQUIPOS.                                                

     10 EQUINO               PIC X(3).                           
     10 EQUINAME.                                                
        49 EQUINAME-LEN      PIC S9(4) USAGE COMP.               
        49 EQUINAME-TEXT     PIC X(36).                          
     10 ENTNO                PIC X(6).                           
     10 EMPREQUI             PIC X(3).                           
     10 CITYNAME.                                                
        49 CITYNAME-LEN      PIC S9(4) USAGE COMP.               
        49 CITYNAME-TEXT     PIC X(16).                          
******************************************************************
* INDICATOR VARIABLE STRUCTURE                                   *
******************************************************************
 01  IEQUIPOS.                                                  
     10 INDSTRUC           PIC S9(4) USAGE COMP OCCURS 5 TIMES.  
******************************************************************
* THE NUMBER OF COLUMNS DESCRIBED BY THIS DECLARATION IS 5       *
******************************************************************


El próximo día seguiremos viendo el procedimiento que hay que seguir para poder hacer uso del contenido del objeto DCL desde el programa Cobol en el que vamos a operar con el fichero DB2. Recordemos que, al fin y al cabo, la finalidad del DCL es que nos facilite el intercambio de información entre el entorno SQL DB2 y el entorno Host Cobol.

Dicho esto, ya sólo nos queda emplazaros a la segunda parte del post, donde terminaremos de ver la forma en que debe utilizarse la herramienta DCLGEN. Disfrutad del Cobol mientras tanto.

Saludos.

jueves, 9 de octubre de 2014

Estructura básica de un programa Cobol (y 2)

Hace algunas semanas comenzamos a repasar la configuración estándar de un programa Cobol (ver post Estructura básica de un programa Cobol - 1). Aunque vimos unas cuantas secciones del código, nos quedaron pendientes otras tantas para completar la revisión de la estructura.

Recordemos que un programa Cobol está organizado en 4 Divisiones principales. De ellas, en la primera parte del post vimos la "Identification Division" y la "Environment Division". A continuación, completaremos la revisión de la estructura viendo las secciones y párrafos de las dos Divisiones restantes.

 

3º) DATA DIVISION

Esta División es, quizás, la más compleja de la programación Cobol, ya que se compone de varias secciones que no resultan del todo intuitivas para los programadores de otros lenguajes más modernos.

DATA DIVISION

A) FILE SECTION

Aquí se definirá la estructura de los ficheros especificados en la INPUT-OUTPUT-SECTION y también habrá que detallar los campos en los que se desglosan los registros asociados a cada uno de dichos ficheros.

   FILE SECTION
      ...
      FICHERO
         REGISTRO
      ... 

B) WORKING-STORAGE SECTION

Aquí deben definirse todas las variables que van a usarse en la lógica procedimental del programa. Se incluyen tanto las variables estándar como las variables auxiliares que se emplearán para trabajar con la información descargada de los ficheros.

   WORKING-STORATE SECTION
      ...
      VARIABLE
      ...

C) LINKAGE SECTION

Aquí se deberán indicar los parámetros (variables) con los que debe invocarse nuestro fuente si es llamado desde otro objeto. Lógicamente, esta sección sólo se usará si estamos codificando un subprograma que debe ser invocado, mediante unos parámetros determinados, por otros objetos de la aplicación.

   LINKAGE SECTION
      ...
      PARAMETRO
      ... 

4º) PROCEDURE DIVISION

Finalmente llegamos a la última División de la estructura de un programa Cobol. En ella tendremos que definir las secciones y párrafos (esto es, las subrutinas) en las que queramos dividir nuestro objeto y, en cada una de ellas, se deberán incluir las sentencias (esto es, las instrucciones) requeridas para la correcta implementación del algoritmo de nuestro programa.

Por supuesto, en la DATA DIVISION tienen que estar definidas todas las variables con las que vayamos a operar en la PROCEDURE DIVISION.

PROCEDURE DIVISION
   ...
   SECCION
      PARRAFO
         SENTENCIA
   ...

Obviamente, la elaboración de un programa Cobol tiene más complejidad que la detallada a lo largo de todo el artículo. Sin embargo, esta estructura básica nos puede servir de guía cuando realicemos la creación de nuestros primeros objetos Cobol. Y esa era la idea del post, servir de ayuda a los programadores novatos.

Como hemos dicho al principio, no hay que desanimarse por la aparente rigidez del Cobol. Todos los lenguales tienen sus particularidades y eso puede hacer que, al principio, nos parezca extraña la forma en que se realiza el tratamiento de algunas cosas. Sin embargo, con un poco de tiempo y de práctica, seremos capaces de adaptarnos al nuevo entorno y codificar nuestros programas con fluidez.

Y nada más. Esperamos que el post os sea de ayuda, sobre todo a los que nos habéis escrito pidiendo esta información enfocada para los programadores menos avanzados.

Saludos.

jueves, 2 de octubre de 2014

Estructura básica de un programa Cobol (1)

Hoy vamos a tratar un tema muy básico de nuestro lenguaje pero para el que, sin embargo, hemos recibido varias cuestiones de lectores principiantes en el mundo Cobol. Se trata de identificar cuáles son todos los apartados que debe incorporar un programa Cobol estándar.

Al principio, si no estamos acostumbrados a trabajar con Cobol, nos puede parecer un poco rígida la forma en que se estructuran los programas en este lenguaje. Sin embargo, una vez vayamos ampliando nuestra experiencia, nos daremos cuenta de que la cosa es tan sencilla como pueda serlo en cualquier otro lenguaje de programación.



Un programa Cobol está estructurado en una serie de Divisiones, Secciones y Párrafos en los que hay que ir declarando la información que corresponda a cada una de ellas. La estructura general sería la siguiente:

IDENTIFICATION DIVISION
   PROGRAM-ID
   AUTHOR
   INSTALLATION
   DATE-WRITTEN
   DATE-COMPILED
   SECURITY

ENVIRONMENT DIVISION

   CONFIGURATION SECTION
      SOURCE-COMPUTER
      OBJECT-COMPUTER
      SPECIAL-NAMES

   INPUT-OUTPUT SECTION
      FILE CONTROL
      I-O-CONTROL

DATA DIVISION

   FILE SECTION
      ...
      FICHERO
         REGISTRO
      ...

   WORKING-STORATE SECTION
      ...
      VARIABLE
      ...

   LINKAGE SECTION
      ...
      PARAMETRO
      ...

PROCEDURE DIVISION
   ...
   SECCION
      PARRAFO
         SENTENCIA
   ...

A continuación, comentamos un poco más en detalle en qué consiste cada una de las Divisiones y Secciones enumeradas anteriormente.

1º) IDENTIFICATION DIVISION

Esta División se utiliza para declarar una serie de variables globales asociadas al programa, tales como el nombre del objeto (PROGRAM-ID), el nombre del autor del objeto (AUTHOR), la instalación (INSTALLATION), las fechas de codificación y de compilación (DATE-WRITTEN y DATE- COMPILED) y la seguridad (SECURITY). En general, se trata de datos informativos que no tienen mayor impacto en la codificación posterior del programa.

IDENTIFICATION DIVISION
   PROGRAM-ID
   AUTHOR
   INSTALLATION
   DATE-WRITTEN
   DATE-COMPILED
   SECURITY 

2º) ENVIRONMENT DIVISION

Esta División se compone de dos importantes secciones, CONFIGURATION SECTION e INPUT-OUTPUT-SECTION, cuyo contenido pasamos a detallar a continuación.

ENVIRONMENT DIVISION

A) CONFIGURATION SECTION

Aquí se especifica información relevante para el programa. Por un lado, se debe indicar el nombre de la máquina empleada para la codificación (SOURCE-COMPUTER y OBJECT-COMPUTER). Por otro lado, en el apartado SPECIAL-NAMES hay que detallar las configuraciones especiales que vaya a tener nuestro programa.

Este último apartado tiene su importancia. En general, en Europa se emplea para hacer la declaración DECIMAL POINT IS COMMA, que le indica al compilador que, en nuestro programa, la parte decimal de un número va a ir precedida de una coma (,) y no de un punto (.) como ocurre en EEUU.

   CONFIGURATION SECTION
      SOURCE-COMPUTER
      OBJECT-COMPUTER
      SPECIAL-NAMES 

B) INPUT-OUTPUT SECTION

En esta sección, en el apartado FILE CONTROL hay que especificar el nombre de los ficheros que se tratarán en nuestro fuente. Se indicará la equivalencia entre el nombre lógico que va a tener un determinado fichero en el programa Cobol y el nombre externo que tendrá en el JCL que lo invoque. Este apartado sólo se rellenará si nuestro objeto va a estar insertado en un proceso batch (por contra, no se usará si se va a tratar de un programa CICS on-line).

Adicionalmente, en esta sección aparece también el apartado I-O-CONTROL, que se usará para indicar el área de memoria que va a ser compartida por los ficheros utilizados en el programa. Este segundo apartado es opcional.

   INPUT-OUTPUT SECTION
      FILE CONTROL
      I-O-CONTROL

El próximo día continuaremos revisando las dos últimas Divisiones del programa Cobol, junto con todas las secciones contenidas en ellas. Os adelantamos que hablaremos de la "Data Division" y de la "Procedure Division", aunque ya las revisaremos en detalle en el siguiente post.

Y eso es todo. Ya sólo nos queda emplazaros a la segunda parte para que podamos completar la revisión de todas las Divisiones y secciones de la estructura básica de un programa Cobol.

Saludos.

Related Posts Plugin for WordPress, Blogger...