COBOL - Guía rápida

Introducción a COBOL

COBOL es un lenguaje de alto nivel. Hay que entender cómo funciona COBOL. Las computadoras solo entienden el código de máquina, un flujo binario de 0 y 1. El código COBOL debe convertirse en código de máquina utilizando uncompiler. Ejecute la fuente del programa a través de un compilador. El compilador primero comprueba si hay errores de sintaxis y luego lo convierte a lenguaje de máquina. El compilador crea un archivo de salida que se conoce comoload module. Este archivo de salida contiene código ejecutable en forma de 0 y 1.

Evolución de COBOL

Durante la década de 1950, cuando las empresas estaban creciendo en la parte occidental del mundo, existía la necesidad de automatizar varios procesos para facilitar la operación y esto dio lugar a un lenguaje de programación de alto nivel destinado al procesamiento de datos comerciales.

En 1959, COBOL fue desarrollado por CODASYL (Conferencia sobre lenguaje de sistemas de datos).
La siguiente versión, COBOL-61, fue lanzada en 1961 con algunas revisiones.
En 1968, COBOL fue aprobado por ANSI como lenguaje estándar para uso comercial (COBOL-68).
Se revisó nuevamente en 1974 y 1985 para desarrollar versiones posteriores denominadas COBOL-74 y COBOL-85 respectivamente.
En 2002, se lanzó COBOL orientado a objetos, que podía utilizar objetos encapsulados como parte normal de la programación COBOL.

Importancia de COBOL

COBOL fue el primer lenguaje de programación de alto nivel ampliamente utilizado. Es un idioma similar al inglés que es fácil de usar. Todas las instrucciones se pueden codificar en palabras sencillas en inglés.
COBOL también se utiliza como lenguaje autodocumentado.
COBOL puede manejar un gran procesamiento de datos.
COBOL es compatible con sus versiones anteriores.
COBOL tiene mensajes de error efectivos y, por lo tanto, la resolución de errores es más fácil.

Características de COBOL

Idioma estándar

COBOL es un lenguaje estándar que se puede compilar y ejecutar en máquinas como IBM AS / 400, computadoras personales, etc.

Orientado a los negocios

COBOL fue diseñado para aplicaciones orientadas a negocios relacionadas con el dominio financiero, dominio de defensa, etc. Puede manejar grandes volúmenes de datos debido a sus capacidades avanzadas de manejo de archivos.

Lenguaje robusto

COBOL es un lenguaje robusto ya que sus numerosas herramientas de depuración y prueba están disponibles para casi todas las plataformas informáticas.

Lenguaje estructurado

Las estructuras de control lógico están disponibles en COBOL, lo que facilita su lectura y modificación. COBOL tiene diferentes divisiones, por lo que es fácil de depurar.

Instalación de COBOL en Windows / Linux

Hay muchos emuladores de mainframe gratuitos disponibles para Windows que se pueden usar para escribir y aprender programas COBOL simples.

Uno de esos emuladores es Hercules, que se puede instalar fácilmente en Windows siguiendo unos sencillos pasos como se indica a continuación:

Descarga e instala el emulador de Hercules, que está disponible en el sitio de inicio de Hercules: www.hercules-390.eu
Una vez que haya instalado el paquete en la máquina con Windows, creará una carpeta como C:/hercules/mvs/cobol.
Ejecute el símbolo del sistema (CMD) y acceda al directorio C: / hercules / mvs / cobol en CMD.
La guía completa sobre varios comandos para escribir y ejecutar programas JCL y COBOL se puede encontrar en:

www.jaymoseley.com/hercules/installmvs/instmvs2.htm

Hercules es una implementación de software de código abierto de las arquitecturas mainframe System / 370 y ESA / 390, además de la última arquitectura z / de 64 bits. Hercules se ejecuta en Linux, Windows, Solaris, FreeBSD y Mac OS X.

Un usuario puede conectarse a un servidor de mainframe de varias formas, como cliente ligero, terminal ficticia, sistema de cliente virtual (VCS) o sistema de escritorio virtual (VDS). Cada usuario válido recibe una identificación de inicio de sesión para ingresar a la interfaz Z / OS (TSO / E o ISPF).

Compilación de programas COBOL

Para ejecutar un programa COBOL en modalidad de proceso por lotes utilizando JCL, es necesario compilar el programa y crear un módulo de carga con todos los subprogramas. El JCL utiliza el módulo de carga y no el programa real en el momento de la ejecución. Las bibliotecas de carga se concatenan y se entregan al JCL en el momento de la ejecución utilizandoJCLLIB o STEPLIB.

Hay muchas utilidades de compilación de mainframe disponibles para compilar un programa COBOL. Algunas empresas corporativas utilizan herramientas de gestión del cambio comoEndevor, que compila y almacena todas las versiones del programa. Esto es útil para rastrear los cambios realizados en el programa.

//COMPILE   JOB ,CLASS = 6,MSGCLASS = X,NOTIFY = &SYSUID             
//*            
//STEP1     EXEC IGYCRCTL,PARM = RMODE,DYNAM,SSRANGE
//SYSIN     DD DSN = MYDATA.URMI.SOURCES(MYCOBB),DISP = SHR
//SYSLIB    DD DSN = MYDATA.URMI.COPYBOOK(MYCOPY),DISP = SHR
//SYSLMOD   DD DSN = MYDATA.URMI.LOAD(MYCOBB),DISP = SHR
//SYSPRINT  DD SYSOUT=*
//*

IGYCRCTL es una utilidad del compilador IBM COBOL. Las opciones del compilador se pasan mediante el parámetro PARM. En el ejemplo anterior, RMODE indica al compilador que utilice el modo de direccionamiento relativo en el programa. El programa COBOL se pasa utilizando el parámetro SYSIN. Copybook es la biblioteca utilizada por el programa en SYSLIB.

Ejecución de programas COBOL

A continuación se muestra un ejemplo de JCL en el que el programa MYPROG se ejecuta utilizando el archivo de entrada MYDATA.URMI.INPUT y produce dos archivos de salida escritos en el spool.

//COBBSTEP  JOB CLASS = 6,NOTIFY = &SYSUID
//
//STEP10    EXEC PGM = MYPROG,PARM = ACCT5000
//STEPLIB   DD DSN = MYDATA.URMI.LOADLIB,DISP = SHR
//INPUT1    DD DSN = MYDATA.URMI.INPUT,DISP = SHR
//OUT1      DD SYSOUT=*
//OUT2      DD SYSOUT=*
//SYSIN     DD *
//CUST1     1000
//CUST2     1001
/*

El módulo de carga de MYPROG se encuentra en MYDATA.URMI.LOADLIB. Es importante tener en cuenta que el JCL anterior solo se puede utilizar para un módulo COBOL que no sea DB2.

Ejecución de programas COBOL-DB2

Para ejecutar un programa COBOL-DB2, se utiliza una utilidad de IBM especializada en el JCL y el programa; La región DB2 y los parámetros necesarios se pasan como entrada a la utilidad.

Los pasos que se siguen para ejecutar un programa COBOL-DB2 son los siguientes:

Cuando se compila un programa COBOL-DB2, se crea un DBRM (Módulo de solicitud de base de datos) junto con el módulo de carga. El DBRM contiene las sentencias SQL de los programas COBOL con su sintaxis verificada para que sea correcta.
El DBRM está vinculado a la región (entorno) de DB2 en la que se ejecutará COBOL. Esto se puede hacer utilizando la utilidad IKJEFT01 en un JCL.
Después del paso de vinculación, el programa COBOL-DB2 se ejecuta utilizando IKJEFT01 (nuevamente) con la biblioteca de carga y la biblioteca DBRM como entrada al JCL.

//STEP001  EXEC PGM = IKJEFT01
//*
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY  DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(MYCOBB) PLAN(PLANNAME) PARM(parameters to cobol program) -
   LIB('MYDATA.URMI.LOADLIB')
   END
/*

En el ejemplo anterior, MYCOBB es el programa COBOL-DB2 que se ejecuta utilizando IKJEFT01. Tenga en cuenta que el nombre del programa, el ID del subsistema DB2 (SSID) y el nombre del plan DB2 se pasan dentro de la declaración SYSTSIN DD. La biblioteca DBRM se especifica en STEPLIB.

La estructura de un programa COBOL consta de divisiones como se muestra en la siguiente imagen:

A continuación se ofrece una breve introducción de estas divisiones:

Sectionsson la subdivisión lógica de la lógica del programa. Una sección es una colección de párrafos.
Paragraphsson la subdivisión de una sección o división. Es un nombre definido por el usuario o predefinido seguido de un punto y consta de cero o más oraciones / entradas.
Sentencesson la combinación de una o más declaraciones. Las oraciones aparecen solo en la división Procedimiento. Una oración debe terminar con un punto.
Statements son declaraciones COBOL significativas que realizan algún procesamiento.
Characters son los más bajos de la jerarquía y no pueden ser divisibles.

Puede correlacionar los términos mencionados anteriormente con el programa COBOL en el siguiente ejemplo:

PROCEDURE DIVISION.
A0000-FIRST-PARA SECTION.
FIRST-PARAGRAPH.
ACCEPT WS-ID            - Statement-1  -----|
MOVE '10' TO WS-ID      - Statement-2       |-- Sentence - 1
DISPLAY WS-ID           - Statement-3  -----|
.

Divisiones

Un programa COBOL consta de cuatro divisiones.

División de identificación

Es la primera y única división obligatoria de cada programa COBOL. El programador y el compilador utilizan esta división para identificar el programa. En esta división, PROGRAM-ID es el único párrafo obligatorio. PROGRAM-ID especifica el nombre del programa que puede constar de 1 a 30 caracteres.

Pruebe el siguiente ejemplo utilizando el Live Demo opción en línea.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
DISPLAY 'Welcome to Tutorialspoint'.
STOP RUN.

A continuación se muestra el JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Welcome to Tutorialspoint

División de Medio Ambiente

La división del entorno se utiliza para especificar archivos de entrada y salida al programa. Consta de dos secciones:

Configuration sectionproporciona información sobre el sistema en el que se escribe y ejecuta el programa. Consta de dos párrafos:
- Computadora de origen: sistema utilizado para compilar el programa.
- Computadora objeto: sistema utilizado para ejecutar el programa.
Input-Output sectionproporciona información sobre los archivos que se utilizarán en el programa. Consta de dos párrafos:
- Control de archivos: proporciona información de conjuntos de datos externos utilizados en el programa.
- Control de E / S: proporciona información de los archivos utilizados en el programa.

ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
   SOURCE-COMPUTER. XXX-ZOS.
   OBJECT-COMPUTER. XXX-ZOS.

INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT FILEN ASSIGN TO DDNAME
   ORGANIZATION IS SEQUENTIAL.

División de datos

La división de datos se utiliza para definir las variables utilizadas en el programa. Consta de cuatro secciones:

File section se utiliza para definir la estructura de registro del archivo.
Working-Storage section se utiliza para declarar variables temporales y estructuras de archivos que se utilizan en el programa.
Local-Storage sectiones similar a la sección Trabajo-Almacenamiento. La única diferencia es que las variables se asignarán e inicializarán cada vez que un programa comience a ejecutarse.
Linkage section se utiliza para describir los nombres de los datos que se reciben de un programa externo.

COBOL Program

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT FILEN ASSIGN TO INPUT.
      ORGANIZATION IS SEQUENTIAL.
      ACCESS IS SEQUENTIAL.

DATA DIVISION.
   FILE SECTION.
   FD FILEN
   01 NAME PIC A(25).
   
   WORKING-STORAGE SECTION.
   01 WS-STUDENT PIC A(30).
   01 WS-ID PIC 9(5).

   LOCAL-STORAGE SECTION.
   01 LS-CLASS PIC 9(3).
   
   LINKAGE SECTION.
   01 LS-ID PIC 9(5).
   
PROCEDURE DIVISION.
   DISPLAY 'Executing COBOL program using JCL'.
STOP RUN.

los JCL para ejecutar el programa COBOL anterior es el siguiente:

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//INPUT DD DSN = ABC.EFG.XYZ,DISP = SHR

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Executing COBOL program using JCL

División de procedimientos

La división de procedimientos se utiliza para incluir la lógica del programa. Consiste en declaraciones ejecutables que utilizan variables definidas en la división de datos. En esta división, los nombres de los párrafos y las secciones los define el usuario.

Debe haber al menos una declaración en la división de procedimientos. La última declaración para finalizar la ejecución en esta división esSTOP RUN que se utiliza en los programas de llamada o EXIT PROGRAM que se utiliza en los programas llamados.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NAME PIC A(30).
   01 WS-ID PIC 9(5) VALUE 12345.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   DISPLAY 'Hello World'.
   MOVE 'TutorialsPoint' TO WS-NAME.
   DISPLAY "My name is : "WS-NAME.
   DISPLAY "My ID is : "WS-ID.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Hello World
My name is : TutorialsPoint
My ID is : 12345

Conjunto de caracteres

Los 'personajes' son los más bajos en la jerarquía y no se pueden dividir más. El juego de caracteres COBOL incluye 78 caracteres que se muestran a continuación:

No Señor.	Descripción del personaje
1	A-Z Alfabetos (mayúsculas)
2	a-z Alfabetos (minúsculas)
3	0-9 Numérico
4	Espacio
5	+ Signo de más
6	- Signo menos o guion
7	* Asterisco
8	/ Barra inclinada
9	$ Signo de moneda
10	, Coma
11	; Punto y coma
12	. Punto o período decimal
13	" Comillas
14	( Paréntesis izquierdo
15	) Paréntesis derecho
dieciséis	> Mas grande que
17	< Menos que
18	: Colon
19	' Apóstrofe
20	= Signo igual

Hoja de codificación

El programa fuente de COBOL debe estar escrito en un formato aceptable para los compiladores. Los programas COBOL están escritos en hojas de codificación COBOL. Hay 80 posiciones de caracteres en cada línea de una hoja de codificación.

Las posiciones de los caracteres se agrupan en los siguientes cinco campos:

Posiciones	Campo	Descripción
1-6	Números de columna	Reservado para números de línea.
7	Indicador	Puede tener un asterisco (*) que indica comentarios, un guión (-) que indica continuación y una barra inclinada (/) que indica avance de formulario.
8-11	Área A	Todas las divisiones, secciones, párrafos y algunas entradas especiales de COBOL deben comenzar en el Área A.
12-72	Área B	Todas las declaraciones COBOL deben comenzar en el área B.
73-80	Área de identificación	Puede ser utilizado por el programador según sea necesario.

Ejemplo

El siguiente ejemplo muestra una hoja de codificación COBOL:

000100 IDENTIFICATION DIVISION.                                         000100
000200 PROGRAM-ID. HELLO.                                               000101
000250* THIS IS A COMMENT LINE                                          000102
000300 PROCEDURE DIVISION.                                              000103
000350 A000-FIRST-PARA.                                                 000104
000400     DISPLAY “Coding Sheet”.                                      000105
000500 STOP RUN.                                                        000106

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Coding Sheet

Cadenas de caracteres

Las cadenas de caracteres se forman combinando caracteres individuales. Una cadena de caracteres puede ser una

Comment,
Literal, o
Palabra COBOL.

Todas las cadenas de caracteres deben terminar con separators. Se utiliza un separador para separar cadenas de caracteres.

Separadores de uso frecuente: espacio, coma, punto, apóstrofo, paréntesis izquierdo / derecho y comillas.

Comentario

Un comentario es una cadena de caracteres que no afecta la ejecución de un programa. Puede ser cualquier combinación de caracteres.

Hay dos tipos de comentarios:

Línea de comentario

Se puede escribir una línea de comentario en cualquier columna. El compilador no comprueba la sintaxis de una línea de comentario y la trata como documentación.

Entrada de comentario

Las entradas de comentarios son aquellas que se incluyen en los párrafos opcionales de una División de Identificación. Están escritos en el Área B y los programadores lo usan como referencia.

El texto resaltado en Bold son las entradas comentadas en el siguiente ejemplo:

000100 IDENTIFICATION DIVISION.                                         000100
000150 PROGRAM-ID. HELLO.                                               000101 
000200 AUTHOR. TUTORIALSPOINT.                                          000102
000250* THIS IS A COMMENT LINE                                          000103
000300 PROCEDURE DIVISION.                                              000104
000350 A000-FIRST-PARA.                                                 000105  
000360/ First Para Begins - Documentation Purpose                       000106
000400     DISPLAY “Comment line”.                                      000107
000500 STOP RUN.                                                        000108

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Comment Line

Literal

Literal es una constante directamente codificada en un programa. En el siguiente ejemplo, "Hello World" es un literal.

PROCEDURE DIVISION.
DISPLAY 'Hello World'.

Hay dos tipos de literales como se explica a continuación:

Literal alfanumérico

Los literales alfanuméricos se incluyen entre comillas o apóstrofos. La longitud puede ser de hasta 160 caracteres. Un apóstrofe o una cita pueden ser parte de un literal solo si están emparejados. El comienzo y el final del literal deben ser iguales, ya sea apóstrofe o comillas.

Example

El siguiente ejemplo muestra literales alfanuméricos válidos e inválidos:

Valid:
   ‘This is valid’
   "This is valid"
   ‘This isn’’t invalid’

Invalid:
   ‘This is invalid”
   ‘This isn’t valid’

Literal numérico

Un literal numérico es una combinación de dígitos del 0 al 9, +, - o punto decimal. La longitud puede tener hasta 18 caracteres. El signo no puede ser el carácter situado más a la derecha. El punto decimal no debe aparecer al final.

Example

El siguiente ejemplo muestra literales numéricos válidos e inválidos:

Valid:
   100
   +10.9
   -1.9

Invalid:
   1,00
   10.
   10.9-

Palabra COBOL

COBOL Word es una cadena de caracteres que puede ser una palabra reservada o una palabra definida por el usuario. La longitud puede tener hasta 30 caracteres.

Usuario definido

Las palabras definidas por el usuario se utilizan para nombrar archivos, datos, registros, nombres de párrafos y secciones. Se permiten alfabetos, dígitos y guiones al formar palabras definidas por el usuario. No puede utilizar palabras reservadas COBOL.

Palabras reservadas

Las palabras reservadas son palabras predefinidas en COBOL. Los diferentes tipos de palabras reservadas que usamos con frecuencia son los siguientes:

Keywords como AGREGAR, ACEPTAR, MOVER, etc.
Special characters palabras como +, -, *, <, <=, etc.
Figurative constants son valores constantes como CERO, ESPACIOS, etc. Todos los valores constantes de constantes figurativas se mencionan en la siguiente tabla.

Constantes figurativas

No Señor.	Constantes figurativas y descripción
1	HIGH-VALUES Uno o más personajes que estarán en la posición más alta en orden descendente.
2	LOW-VALUES Uno o más caracteres tienen ceros en representación binaria.
3	ZERO/ZEROES Uno o más cero según el tamaño de la variable.
4	SPACES Uno o más espacios.
5	QUOTES Comillas simples o dobles.
6	ALL literal Rellena el elemento de datos con Literal.

La división de datos se utiliza para definir las variables utilizadas en un programa. Para describir datos en COBOL, uno debe comprender los siguientes términos:

Nombre de datos
Número de nivel
Cláusula de imagen
Cláusula de valor

01            TOTAL-STUDENTS            PIC9(5)            VALUE '125'.
|                    |                    |                    |
|                    |                    |                    |
|                    |                    |                    | 
Level Number     Data Name           Picture Clause       Value Clause

Nombre de datos

Los nombres de los datos deben definirse en la División de datos antes de usarlos en la División de procedimientos. Deben tener un nombre definido por el usuario; no se pueden utilizar palabras reservadas. Los nombres de los datos hacen referencia a las ubicaciones de la memoria donde se almacenan los datos reales. Pueden ser de tipo elemental o grupal.

Ejemplo

El siguiente ejemplo muestra nombres de datos válidos y no válidos:

Valid:
   WS-NAME
   TOTAL-STUDENTS
   A100
   100B

Invalid:
   MOVE            (Reserved Words)
   COMPUTE         (Reserved Words)
   100             (No Alphabet)
   100+B           (+ is not allowed)

Número de nivel

El número de nivel se utiliza para especificar el nivel de datos en un registro. Se utilizan para diferenciar entre elementos elementales y elementos de grupo. Los elementos elementales se pueden agrupar para crear elementos de grupo.

No Señor.	Número de nivel y descripción
1	01 Entrada de descripción de registro
2	02 to 49 Elementos elementales y grupales
3	66 Cambiar el nombre de los elementos de la cláusula
4	77 Elementos que no se pueden subdividir
5	88 Entrada de nombre de condición

Elementary itemsno se puede dividir más. El número de nivel, el nombre de los datos, la cláusula de imagen y la cláusula de valor (opcional) se utilizan para describir un elemento elemental.
Group itemsconstan de uno o más elementos elementales. El número de nivel, el nombre de los datos y la cláusula de valor (opcional) se utilizan para describir un elemento de grupo. El número de nivel de grupo es siempre 01.

Ejemplo

El siguiente ejemplo muestra elementos de grupo y elementales:

DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NAME    PIC X(25).                               ---> ELEMENTARY ITEM 
01 WS-CLASS   PIC 9(2)  VALUE  '10'.                   ---> ELEMENTARY ITEM

01 WS-ADDRESS.                                         ---> GROUP ITEM   
   05 WS-HOUSE-NUMBER    PIC 9(3).                     ---> ELEMENTARY ITEM
   05 WS-STREET          PIC X(15).                    ---> ELEMENTARY ITEM
   05 WS-CITY            PIC X(15).                    ---> ELEMENTARY ITEM
   05 WS-COUNTRY         PIC X(15)  VALUE 'INDIA'.     ---> ELEMENTARY ITEM

Cláusula de imagen

La cláusula de imagen se utiliza para definir los siguientes elementos:

Data typepuede ser numérico, alfabético o alfanumérico. El tipo numérico consta únicamente de dígitos del 0 al 9. El tipo alfabético consta de letras de la A a la Z y espacios. El tipo alfanumérico consta de dígitos, letras y caracteres especiales.
Signse puede utilizar con datos numéricos. Puede ser + o -.
Decimal point positionse puede utilizar con datos numéricos. La posición asumida es la posición del punto decimal y no se incluye en los datos.
Length define el número de bytes usados por el elemento de datos.

Símbolos utilizados en una cláusula de imagen:

No Señor.	Símbolo y descripción
1	9 Numérico
2	A Alfabético
3	X Alfanumérico
4	V Decimal implícito
5	S Firmar
6	P Decimal asumido

Ejemplo

El siguiente ejemplo muestra el uso de la cláusula PIC:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC S9(3)V9(2).
   01 WS-NUM2 PIC PPP999.
   01 WS-NUM3 PIC S9(3)V9(2) VALUE -123.45.
   01 WS-NAME PIC A(6) VALUE 'ABCDEF'.
   01 WS-ID PIC X(5) VALUE 'A121$'.

PROCEDURE DIVISION.
   DISPLAY "WS-NUM1 : "WS-NUM1.
   DISPLAY "WS-NUM2 : "WS-NUM2.
   DISPLAY "WS-NUM3 : "WS-NUM3.
   DISPLAY "WS-NAME : "WS-NAME.
   DISPLAY "WS-ID : "WS-ID.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1 : +000.00
WS-NUM2 : .000000
WS-NUM3 : -123.45
WS-NAME : ABCDEF
WS-ID : A121$

Cláusula de valor

La cláusula de valor es una cláusula opcional que se utiliza para inicializar los elementos de datos. Los valores pueden ser literal numérico, literal alfanumérico o constante figurativa. Se puede utilizar tanto con elementos grupales como elementales.

Ejemplo

El siguiente ejemplo muestra el uso de la cláusula VALUE:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 99V9 VALUE IS 3.5.
   01 WS-NAME PIC A(6) VALUE 'ABCD'.
   01 WS-ID PIC 99 VALUE ZERO.

PROCEDURE DIVISION.
   DISPLAY "WS-NUM1 : "WS-NUM1.
   DISPLAY "WS-NAME : "WS-NAME.
   DISPLAY "WS-ID   : "WS-ID.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1 : 03.5
WS-NAME : ABCD
WS-ID   : 00

Los verbos COBOL se utilizan en la división de procedimientos para el procesamiento de datos. Una declaración siempre comienza con un verbo COBOL. Hay varios verbos COBOL con diferentes tipos de acciones.

Verbos de entrada / salida

Los verbos de entrada / salida se utilizan para obtener datos del usuario y mostrar la salida de los programas COBOL. Los siguientes dos verbos se utilizan para este proceso:

Aceptar verbo

Aceptar verbo se utiliza para obtener datos como la fecha, la hora y el día del sistema operativo o directamente del usuario. Si un programa acepta datos del usuario, debe pasar a través de JCL. Al obtener datos del sistema operativo, la opción FROM se incluye como se muestra en el siguiente ejemplo:

ACCEPT WS-STUDENT-NAME.
ACCEPT WS-DATE FROM SYSTEM-DATE.

Verbo de visualización

Mostrar verbo se utiliza para mostrar la salida de un programa COBOL.

DISPLAY WS-STUDENT-NAME.
DISPLAY "System date is : " WS-DATE.

COBOL PROGRAM

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STUDENT-NAME PIC X(25).
   01 WS-DATE PIC X(10).

PROCEDURE DIVISION.
   ACCEPT WS-STUDENT-NAME.
   ACCEPT WS-DATE FROM DATE.
   DISPLAY "Name :  " WS-STUDENT-NAME.
   DISPLAY "Date : " WS-DATE.

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//INPUT DD DSN=PROGRAM.DIRECTORY,DISP=SHR
//SYSIN DD *
TutorialsPoint
/*

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Name : TutorialsPoint
Date : 200623

Inicializar verbo

El verbo inicializar se utiliza para inicializar un elemento de grupo o un elemento elemental. Los nombres de datos con la cláusula RENAME no se pueden inicializar. Los elementos de datos numéricos se reemplazan por CERO. Los elementos de datos alfanuméricos o alfabéticos se reemplazan por ESPACIOS. Si incluimos el término REPLACING, entonces los elementos de datos se pueden inicializar al valor de reemplazo dado como se muestra en el siguiente ejemplo:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NAME PIC A(30) VALUE 'ABCDEF'.
   01 WS-ID PIC 9(5).
   01 WS-ADDRESS. 
   05 WS-HOUSE-NUMBER PIC 9(3).
   05 WS-COUNTRY PIC X(15).
   05 WS-PINCODE PIC 9(6) VALUE 123456.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   INITIALIZE WS-NAME, WS-ADDRESS.
   INITIALIZE WS-ID REPLACING NUMERIC DATA BY 12345.
   DISPLAY "My name is   : "WS-NAME.
   DISPLAY "My ID is     : "WS-ID.
   DISPLAY "Address      : "WS-ADDRESS.
   DISPLAY "House Number : "WS-HOUSE-NUMBER.
   DISPLAY "Country      : "WS-COUNTRY.
   DISPLAY "Pincode      : "WS-PINCODE.

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

My name is   :                               
My ID is     : 12345
Address      : 000               000000
House Number : 000
Country      :                
Pincode      : 000000

Mover Verbo

Mover verbo se utiliza para copiar datos de los datos de origen a los datos de destino. Se puede utilizar tanto en elementos de datos elementales como grupales. Para elementos de datos de grupo, se utiliza MOVE CORRESPONDING / CORR. En la opción de probarlo, MOVE CORR no funciona; pero en un servidor de mainframe, funcionará.

Para mover datos de una cadena, se usa MOVE (x: l) donde x es la posición inicial y l es la longitud. Los datos se truncarán si la cláusula PIC del elemento de datos de destino es menor que la cláusula PIC del elemento de datos de origen. Si la cláusula PIC del elemento de datos de destino es mayor que la cláusula PIC del elemento de datos de origen, se agregarán ZEROS o SPACES en los bytes adicionales. El siguiente ejemplo lo aclara.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9).
   01 WS-NUM2 PIC 9(9).
   01 WS-NUM3 PIC 9(5).
   01 WS-NUM4 PIC 9(6).
   01 WS-ADDRESS. 
   05 WS-HOUSE-NUMBER PIC 9(3).
   05 WS-COUNTRY PIC X(5).
   05 WS-PINCODE PIC 9(6).
   01 WS-ADDRESS1. 
   05 WS-HOUSE-NUMBER1 PIC 9(3).
   05 WS-COUNTRY1 PIC X(5).
   05 WS-PINCODE1 PIC 9(6).

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 123456789 TO WS-NUM1.
   MOVE WS-NUM1 TO WS-NUM2 WS-NUM3.
   MOVE WS-NUM1(3:6) TO WS-NUM4.
   MOVE 123 TO WS-HOUSE-NUMBER.
   MOVE 'INDIA' TO WS-COUNTRY.
   MOVE 112233 TO WS-PINCODE.
   MOVE WS-ADDRESS TO WS-ADDRESS1.

   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUM4     : " WS-NUM4
   DISPLAY "WS-ADDRESS  : " WS-ADDRESS
   DISPLAY "WS-ADDRESS1 : " WS-ADDRESS1

STOP RUN.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1     : 123456789
WS-NUM2     : 123456789
WS-NUM3     : 56789
WS-NUM4     : 345678
WS-ADDRESS  : 123INDIA112233
WS-ADDRESS1 : 123INDIA112233

Movimientos legales

La siguiente tabla brinda información sobre los movimientos legales:

	Alfabético	Alfanumérico	Numérico
Alfabético	Posible	Posible	Imposible
Alfanumérico	Posible	Posible	Posible
Numérico	Imposible	Posible	Posible

Agregar verbo

Agregar verbo se utiliza para sumar dos o más números y almacenar el resultado en el operando de destino.

Sintaxis

A continuación se muestra la sintaxis para sumar dos o más números:

ADD A B TO C D

ADD A B C TO D GIVING E

ADD CORR WS-GROUP1 TO WS-GROUP2

En la sintaxis-1, se agregan A, B, C y el resultado se almacena en C (C = A + B + C). Se suman A, B, D y el resultado se almacena en D (D = A + B + D).

En la sintaxis-2, se agregan A, B, C, D y el resultado se almacena en E (E = A + B + C + D).

En la sintaxis-3, se agregan elementos de subgrupo dentro de WS-GROUP1 y WS-GROUP2 y el resultado se almacena en WS-GROUP2.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 10.
   01 WS-NUM4 PIC 9(9) VALUE 10.
   01 WS-NUMA PIC 9(9) VALUE 10.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9) VALUE 10.
   01 WS-NUMD PIC 9(9) VALUE 10.
   01 WS-NUME PIC 9(9) VALUE 10.

PROCEDURE DIVISION.
   ADD WS-NUM1 WS-NUM2 TO WS-NUM3 WS-NUM4.
   ADD WS-NUMA WS-NUMB WS-NUMC TO WS-NUMD GIVING WS-NUME.
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUM4     : " WS-NUM4
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   DISPLAY "WS-NUMD     : " WS-NUMD
   DISPLAY "WS-NUME     : " WS-NUME

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1     : 000000010
WS-NUM2     : 000000010
WS-NUM3     : 000000030
WS-NUM4     : 000000030
WS-NUMA     : 000000010
WS-NUMB     : 000000010
WS-NUMC     : 000000010
WS-NUMD     : 000000010
WS-NUME     : 000000040

Restar Verbo

Restar verbo se utiliza para operaciones de resta.

Sintaxis

A continuación se muestra la sintaxis para las operaciones de resta:

SUBTRACT A B FROM C D

SUBTRACT A B C FROM D GIVING E

SUBTRACT CORR WS-GROUP1 TO WS-GROUP2

En la sintaxis-1, A y B se suman y se restan de C. El resultado se almacena en C (C = C- (A + B)). A y B se suman y se restan de D. El resultado se almacena en D (D = D- (A + B)).

En la sintaxis-2, A, B, C se suman y se restan de D. El resultado se almacena en E (E = D- (A + B + C))

En la sintaxis-3, los elementos del subgrupo dentro de WS-GROUP1 y WS-GROUP2 se restan y el resultado se almacena en WS-GROUP2.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 100.
   01 WS-NUM4 PIC 9(9) VALUE 100.
   01 WS-NUMA PIC 9(9) VALUE 10.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9) VALUE 10.
   01 WS-NUMD PIC 9(9) VALUE 100.
   01 WS-NUME PIC 9(9) VALUE 10.

PROCEDURE DIVISION.
   SUBTRACT WS-NUM1 WS-NUM2 FROM WS-NUM3 WS-NUM4.
   SUBTRACT WS-NUMA WS-NUMB WS-NUMC FROM WS-NUMD GIVING WS-NUME.

   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUM4     : " WS-NUM4
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   DISPLAY "WS-NUMD     : " WS-NUMD
   DISPLAY "WS-NUME     : " WS-NUME

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1     : 000000010
WS-NUM2     : 000000010
WS-NUM3     : 000000080
WS-NUM4     : 000000080
WS-NUMA     : 000000010
WS-NUMB     : 000000010
WS-NUMC     : 000000010
WS-NUMD     : 000000100
WS-NUME     : 000000070

Multiplicar verbo

El verbo multiplicar se usa para operaciones de multiplicación.

Sintaxis

A continuación se muestra la sintaxis para multiplicar dos o más números:

MULTIPLY A BY B C

MULTIPLY A BY B GIVING E

En la sintaxis-1, A y B se multiplican y el resultado se almacena en B (B = A * B). A y C se multiplican y el resultado se almacena en C (C = A * C).

En la sintaxis-2, A y B se multiplican y el resultado se almacena en E (E = A * B).

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 10.
   01 WS-NUMA PIC 9(9) VALUE 10.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9) VALUE 10.

PROCEDURE DIVISION.
   MULTIPLY WS-NUM1 BY WS-NUM2 WS-NUM3.
   MULTIPLY WS-NUMA BY WS-NUMB GIVING WS-NUMC.
   
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1     : 000000010
WS-NUM2     : 000000100
WS-NUM3     : 000000100
WS-NUMA     : 000000010
WS-NUMB     : 000000010
WS-NUMC     : 000000100

Dividir verbo

El verbo dividir se usa para operaciones de división.

Sintaxis

A continuación se muestra la sintaxis para las operaciones de división:

DIVIDE A INTO B

DIVIDE A BY B GIVING C REMAINDER R

En la sintaxis-1, B se divide por A y el resultado se almacena en B (B = B / A).

En la sintaxis-2, A se divide por B y el resultado se almacena en C (C = A / B) y el resto se almacena en R.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 5.
   01 WS-NUM2 PIC 9(9) VALUE 250.
   01 WS-NUMA PIC 9(9) VALUE 100.
   01 WS-NUMB PIC 9(9) VALUE 15.
   01 WS-NUMC PIC 9(9).
   01 WS-REM PIC 9(9). 

PROCEDURE DIVISION.
   DIVIDE WS-NUM1 INTO WS-NUM2.
   DIVIDE WS-NUMA BY WS-NUMB GIVING WS-NUMC REMAINDER WS-REM.
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC
   DISPLAY "WS-REM      : " WS-REM
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1     : 000000005
WS-NUM2     : 000000050
WS-NUMA     : 000000100
WS-NUMB     : 000000015
WS-NUMC     : 000000006
WS-REM      : 000000010

Declaración de cálculo

La instrucción Compute se usa para escribir expresiones aritméticas en COBOL. Este es un reemplazo para sumar, restar, multiplicar y dividir.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9) VALUE 10 .
   01 WS-NUM2 PIC 9(9) VALUE 10.
   01 WS-NUM3 PIC 9(9) VALUE 10.
   01 WS-NUMA PIC 9(9) VALUE 50.
   01 WS-NUMB PIC 9(9) VALUE 10.
   01 WS-NUMC PIC 9(9).

PROCEDURE DIVISION.
   COMPUTE WS-NUMC= (WS-NUM1 * WS-NUM2) - (WS-NUMA / WS-NUMB) + WS-NUM3.
   DISPLAY "WS-NUM1     : " WS-NUM1
   DISPLAY "WS-NUM2     : " WS-NUM2
   DISPLAY "WS-NUM3     : " WS-NUM3
   DISPLAY "WS-NUMA     : " WS-NUMA
   DISPLAY "WS-NUMB     : " WS-NUMB
   DISPLAY "WS-NUMC     : " WS-NUMC

STOP RUN.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1     : 000000010
WS-NUM2     : 000000010
WS-NUM3     : 000000010
WS-NUMA     : 000000050
WS-NUMB     : 000000010
WS-NUMC     : 000000105

El diseño COBOL es la descripción del uso de cada campo y los valores presentes en él. A continuación se muestran las entradas de descripción de datos utilizadas en COBOL:

Redefine la cláusula
Cambiar el nombre de la cláusula
Cláusula de uso
Copybooks

Redefine la cláusula

La cláusula Redefines se utiliza para definir un almacenamiento con una descripción de datos diferente. Si uno o más elementos de datos no se utilizan simultáneamente, entonces se puede utilizar el mismo almacenamiento para otro elemento de datos. Por tanto, se puede hacer referencia al mismo almacenamiento con diferentes elementos de datos.

Sintaxis

A continuación se muestra la sintaxis de la cláusula Redefines:

01 WS-OLD PIC X(10).
01 WS-NEW1 REDEFINES WS-OLD PIC 9(8).
01 WS-NEW2 REDEFINES WS-OLD PIC A(10).

A continuación se muestran los detalles de los parámetros utilizados:

WS-OLD es un artículo redefinido
WS-NEW1 y WS-NEW2 están redefiniendo el artículo

Los números de nivel del artículo redefinido y del artículo redefinido deben ser los mismos y no puede ser un número de nivel 66 o 88. No use la cláusula VALUE con un artículo redefinido. En la Sección de Archivo, no use una cláusula de redefinición con el número de nivel 01. La definición de redefinición debe ser la siguiente descripción de datos que desee redefinir. Un artículo redefinido siempre tendrá el mismo valor que un artículo redefinido.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-DESCRIPTION.
   05 WS-DATE1 VALUE '20140831'.
   10 WS-YEAR PIC X(4).
   10 WS-MONTH PIC X(2).
   10 WS-DATE PIC X(2).
   05 WS-DATE2 REDEFINES WS-DATE1 PIC 9(8).

PROCEDURE DIVISION.
   DISPLAY "WS-DATE1 : "WS-DATE1.
   DISPLAY "WS-DATE2 : "WS-DATE2.

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-DATE1 : 20140831
WS-DATE2 : 20140831

Cambiar el nombre de la cláusula

La cláusula de cambio de nombre se utiliza para dar diferentes nombres a elementos de datos existentes. Se utiliza para reagrupar los nombres de los datos y darles un nuevo nombre. Los nuevos nombres de datos pueden cambiar de nombre en grupos o elementos elementales. El nivel 66 está reservado para cambios de nombre.

Syntax

A continuación se muestra la sintaxis de la cláusula Renames:

01 WS-OLD.
10 WS-A PIC 9(12).
10 WS-B PIC X(20).
10 WS-C PIC A(25).
10 WS-D PIC X(12).
66 WS-NEW RENAMES WS-A THRU WS-C.

El cambio de nombre solo es posible en el mismo nivel. En el ejemplo anterior, WS-A, WS-B y WS-C están al mismo nivel. La definición de cambio de nombre debe ser la siguiente descripción de datos que desee cambiar de nombre. No utilice Renombrados con números de nivel 01, 77 o 66. Los nombres de datos utilizados para los cambios de nombre deben venir en secuencia. No se puede cambiar el nombre de los elementos de datos con cláusula de ocurrencia.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-DESCRIPTION.
   05 WS-NUM.
   10 WS-NUM1 PIC 9(2) VALUE 20.
   10 WS-NUM2 PIC 9(2) VALUE 56.
   05 WS-CHAR.
   10 WS-CHAR1 PIC X(2) VALUE 'AA'.
   10 WS-CHAR2 PIC X(2) VALUE 'BB'.
   66 WS-RENAME RENAMES WS-NUM2 THRU WS-CHAR2.

PROCEDURE DIVISION.
   DISPLAY "WS-RENAME : " WS-RENAME.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-RENAME : 56AABB

Cláusula de uso

La cláusula de uso especifica el sistema operativo en el que se almacenan los datos de formato. No se puede usar con los números de nivel 66 u 88. Si se especifica una cláusula de uso en un grupo, todos los elementos elementales tendrán la misma cláusula de uso. Las diferentes opciones disponibles con la cláusula de uso son las siguientes:

Monitor

El elemento de datos se almacena en formato ASCII y cada carácter ocupará 1 byte. Es el uso predeterminado.

El siguiente ejemplo calcula el número de bytes necesarios:

01 WS-NUM PIC S9(5)V9(3) USAGE IS DISPLAY.
It requires 8 bytes as sign and decimal doesn't require any byte.

01 WS-NUM PIC 9(5) USAGE IS DISPLAY.
It requires 5 bytes as sign.

COMPUTACIONAL / COMP

El elemento de datos se almacena en formato binario. Aquí, los elementos de datos deben ser números enteros.

El siguiente ejemplo calcula el número de bytes necesarios:

01 WS-NUM PIC S9(n) USAGE IS COMP.

If 'n' = 1 to 4, it takes 2 bytes.
If 'n' = 5 to 9, it takes 4 bytes.
If 'n' = 10 to 18, it takes 8 bytes.

COMP-1

El elemento de datos es similar a Real o Float y se representa como un número de punto flotante de precisión simple. Internamente, los datos se almacenan en formato hexadecimal. COMP-1 no acepta la cláusula PIC. Aquí 1 palabra equivale a 4 bytes.

COMP-2

El elemento de datos es similar a Long o Double y se representa como un número de punto flotante de precisión doble. Internamente, los datos se almacenan en formato hexadecimal. COMP-2 no especifica la cláusula PIC. Aquí 2 palabras equivalen a 8 bytes.

COMP-3

El elemento de datos se almacena en formato decimal empaquetado. Cada dígito ocupa medio byte (1 nibble) y el signo se almacena en el nibble del extremo derecho.

El siguiente ejemplo calcula el número de bytes necesarios:

01 WS-NUM PIC 9(n) USAGE IS COMP.
Number of bytes = n/2 (If n is even)
Number of bytes = n/2 + 1(If n is odd, consider only integer part)

01 WS-NUM PIC 9(4) USAGE IS COMP-3 VALUE 21.
It requires 2 bytes of storage as each digit occupies half a byte.

01 WS-NUM PIC 9(5) USAGE IS COMP-3 VALUE 21.
It requires 3 bytes of storage as each digit occupies half a byte.

Cuadernos

Un libro de copias COBOL es una selección de código que define las estructuras de datos. Si se usa una estructura de datos en particular en muchos programas, entonces en lugar de escribir la misma estructura de datos nuevamente, podemos usar cuadernos. Usamos la declaración COPY para incluir un cuaderno en un programa. La instrucción COPY se usa en la sección WorkingStorage.

El siguiente ejemplo incluye un cuaderno dentro de un programa COBOL:

DATA DIVISION.
WORKING-STORAGE SECTION.
COPY ABC.

Aquí ABC es el nombre del cuaderno. Los siguientes elementos de datos en el cuaderno ABC se pueden utilizar dentro de un programa.

01 WS-DESCRIPTION.
   05 WS-NUM.
      10 WS-NUM1 PIC 9(2) VALUE 20.
      10 WS-NUM2 PIC 9(2) VALUE 56.
   05 WS-CHAR.
      10 WS-CHAR1 PIC X(2) VALUE 'AA'.
      10 WS-CHAR2 PIC X(2) VALUE 'BB'.

Las sentencias condicionales se utilizan para cambiar el flujo de ejecución en función de determinadas condiciones especificadas por el programador. Las declaraciones condicionales siempre se evaluarán como verdaderas o falsas. Las condiciones se utilizan en las declaraciones IF, Evaluate y Perform. Los diferentes tipos de condiciones son los siguientes:

Declaración de condición IF
Condición de relación
Condición de la señal
Condición de clase
Condición Nombre Condición
Condición negada
Condición combinada

Declaración de condición IF

La declaración IF comprueba las condiciones. Si una condición es verdadera, se ejecuta el bloque IF; y si la condición es falsa, se ejecuta el bloque ELSE.

END-IFse utiliza para finalizar el bloque IF. Para finalizar el bloque IF, se puede utilizar un punto en lugar de END-IF. Pero siempre es preferible usar END-IF para múltiples bloques IF.

Nested-IF- Bloques IF que aparecen dentro de otro bloque IF. No hay límite para la profundidad de las declaraciones IF anidadas.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condición IF:

IF [condition] THEN
   [COBOL statements]
ELSE
   [COBOL statements]
END-IF.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9).
   01 WS-NUM2 PIC 9(9).
   01 WS-NUM3 PIC 9(5).
   01 WS-NUM4 PIC 9(6).

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 25 TO WS-NUM1 WS-NUM3.
   MOVE 15 TO WS-NUM2 WS-NUM4.
   
   IF WS-NUM1 > WS-NUM2 THEN
      DISPLAY 'IN LOOP 1 - IF BLOCK'
      
      IF WS-NUM3 = WS-NUM4 THEN
         DISPLAY 'IN LOOP 2 - IF BLOCK'
      ELSE
         DISPLAY 'IN LOOP 2 - ELSE BLOCK'
      END-IF
      
   ELSE
      DISPLAY 'IN LOOP 1 - ELSE BLOCK'
   END-IF.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

IN LOOP 1 - IF BLOCK
IN LOOP 2 - ELSE BLOCK

Condición de relación

La condición de relación compara dos operandos, cualquiera de los cuales puede ser un identificador, literal o expresión aritmética. La comparación algebraica de campos numéricos se realiza independientemente del tamaño y la cláusula de uso.

For non-numeric operands

Si se comparan dos operandos no numéricos de igual tamaño, los caracteres se comparan desde la izquierda con las posiciones correspondientes hasta que se llega al final. El operando que contiene mayor número de caracteres se declara mayor.

Si se comparan dos operandos no numéricos de tamaño desigual, entonces el elemento de datos más corto se agrega con espacios al final hasta que el tamaño de los operandos se vuelve igual y luego se compara de acuerdo con las reglas mencionadas en el punto anterior.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condiciones de relación:

[Data Name/Arithmetic Operation]

   [IS] [NOT] 

[Equal to (=),Greater than (>), Less than (<), 
Greater than or Equal (>=), Less than or equal (<=) ]

[Data Name/Arithmetic Operation]

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(9).
   01 WS-NUM2 PIC 9(9).

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 25 TO WS-NUM1.
   MOVE 15 TO WS-NUM2.
   
   IF WS-NUM1 IS GREATER THAN OR EQUAL TO WS-NUM2 THEN
      DISPLAY 'WS-NUM1 IS GREATER THAN WS-NUM2'
   ELSE
      DISPLAY 'WS-NUM1 IS LESS THAN WS-NUM2'
   END-IF.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1 IS GREATER THAN WS-NUM2

Condición de la señal

La condición de signo se utiliza para verificar el signo de un operando numérico. Determina si un valor numérico dado es mayor, menor o igual que CERO.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condición de signos:

[Data Name/Arithmetic Operation] 

   [IS] [NOT] 

[Positive, Negative or Zero]

[Data Name/Arithmetic Operation]

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC S9(9) VALUE -1234.
   01 WS-NUM2 PIC S9(9) VALUE 123456.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   IF WS-NUM1 IS POSITIVE THEN
      DISPLAY 'WS-NUM1 IS POSITIVE'.
      
   IF WS-NUM1 IS NEGATIVE THEN
      DISPLAY 'WS-NUM1 IS NEGATIVE'.
      
   IF WS-NUM1 IS ZERO THEN
      DISPLAY 'WS-NUM1 IS ZERO'.
      
   IF WS-NUM2 IS POSITIVE THEN
      DISPLAY 'WS-NUM2 IS POSITIVE'.

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1 IS NEGATIVE
WS-NUM2 IS POSITIVE

Condición de clase

La condición de clase se usa para verificar si un operando contiene solo alfabetos o datos numéricos. Los espacios se consideran en ALFABÉTICO, ALFABÉTICO-INFERIOR y ALFABÉTICO-SUPERIOR.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condición de clase:

[Data Name/Arithmetic Operation>]

   [IS] [NOT] 

[NUMERIC, ALPHABETIC, ALPHABETIC-LOWER, ALPHABETIC-UPPER]

[Data Name/Arithmetic Operation]

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC X(9) VALUE 'ABCD '.
   01 WS-NUM2 PIC 9(9) VALUE 123456789.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   
   IF WS-NUM1 IS ALPHABETIC THEN
      DISPLAY 'WS-NUM1 IS ALPHABETIC'.
      
   IF WS-NUM1 IS NUMERIC THEN
      DISPLAY 'WS-NUM1 IS NUMERIC'.
      
   IF WS-NUM2 IS NUMERIC THEN
      DISPLAY 'WS-NUM2 IS NUMERIC'.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-NUM1 IS ALPHABETIC
WS-NUM2 IS NUMERIC

Condición nombre-condición

Un nombre-condición es un nombre definido por el usuario. Contiene un conjunto de valores especificados por el usuario. Se comporta como variables booleanas. Se definen con el nivel número 88. No tendrá cláusula PIC.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condiciones definidas por el usuario:

88 [Condition-Name] VALUE [IS, ARE] [LITERAL] [THRU LITERAL].

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM PIC 9(3).
   88 PASS VALUES ARE 041 THRU 100.
   88 FAIL VALUES ARE 000 THRU 40.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   MOVE 65 TO WS-NUM.
   
   IF PASS 
      DISPLAY 'Passed with ' WS-NUM ' marks'.
      
   IF FAIL 
      DISPLAY 'FAILED with ' WS-NUM 'marks'.
      
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Passed with 065 marks

Condición negada

La condición negada se da utilizando la palabra clave NOT. Si una condición es verdadera y le hemos dado NOT delante de ella, entonces su valor final será falso.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condiciones negadas:

IF NOT [CONDITION] 
   COBOL Statements
END-IF.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(2) VALUE 20.
   01 WS-NUM2 PIC 9(9) VALUE 25.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   
   IF NOT WS-NUM1 IS LESS THAN WS-NUM2 THEN
      DISPLAY 'IF-BLOCK'
   ELSE
      DISPLAY 'ELSE-BLOCK'
   END-IF.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

ELSE-BLOCK

Condición combinada

Una condición combinada contiene dos o más condiciones conectadas mediante operadores lógicos Y u O.

Sintaxis

A continuación se muestra la sintaxis de las declaraciones de condiciones combinadas:

IF [CONDITION] AND [CONDITION]
   COBOL Statements
END-IF.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-NUM1 PIC 9(2) VALUE 20.
   01 WS-NUM2 PIC 9(2) VALUE 25.
   01 WS-NUM3 PIC 9(2) VALUE 20.

PROCEDURE DIVISION.
   A000-FIRST-PARA.
   
   IF WS-NUM1 IS LESS THAN WS-NUM2 AND WS-NUM1=WS-NUM3 THEN
      DISPLAY 'Both condition OK'
   ELSE
      DISPLAY 'Error'
   END-IF.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Both condition OK

Evaluar Verbo

Evaluar verbo es un reemplazo de una serie de instrucciones IF-ELSE. Se puede usar para evaluar más de una condición. Es similar a la instrucción SWITCH en los programas C.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-A PIC 9 VALUE 0.
   
PROCEDURE DIVISION.
   MOVE 3 TO WS-A.
   
   EVALUATE TRUE
      WHEN WS-A > 2
         DISPLAY 'WS-A GREATER THAN 2'

      WHEN WS-A < 0
         DISPLAY 'WS-A LESS THAN 0'

      WHEN OTHER
         DISPLAY 'INVALID VALUE OF WS-A'
   END-EVALUATE.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-A GREATER THAN 2

Hay algunas tareas que deben realizarse una y otra vez, como leer cada registro de un archivo hasta el final. Las sentencias de bucle utilizadas en COBOL son:

Realizar a través de
Realizar hasta
Realizar tiempos
Realizar variando

Realizar a través de

Perform Thru se utiliza para ejecutar una serie de párrafos dando el nombre y el apellido del párrafo en la secuencia. Después de ejecutar el último párrafo, se devuelve el control.

Rendimiento en línea

Las instrucciones dentro de PERFORM se ejecutarán hasta que se alcance END-PERFORM.

Sintaxis

A continuación se muestra la sintaxis de ejecución en línea:

PERFORM 
   DISPLAY 'HELLO WORLD'
END-PERFORM.

Rendimiento fuera de línea

Aquí, una declaración se ejecuta en un párrafo y luego el control se transfiere a otro párrafo o sección.

Sintaxis

A continuación se muestra la sintaxis de ejecución fuera de línea:

PERFORM PARAGRAPH1 THRU PARAGRAPH2

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

PROCEDURE DIVISION.
   A-PARA.
   PERFORM DISPLAY 'IN A-PARA'
   END-PERFORM.
   PERFORM C-PARA THRU E-PARA.
   
   B-PARA.
   DISPLAY 'IN B-PARA'.
   STOP RUN.
   
   C-PARA.
   DISPLAY 'IN C-PARA'.
   
   D-PARA.
   DISPLAY 'IN D-PARA'.
   
   E-PARA.
   DISPLAY 'IN E-PARA'.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

IN A-PARA
IN C-PARA
IN D-PARA
IN E-PARA
IN B-PARA

Realizar hasta

En 'ejecutar hasta', se ejecuta un párrafo hasta que la condición dada se vuelve verdadera. 'Con prueba antes' es la condición predeterminada e indica que la condición se verifica antes de la ejecución de declaraciones en un párrafo.

Sintaxis

A continuación se muestra la sintaxis de realizar hasta:

PERFORM A-PARA UNTIL COUNT=5

PERFORM A-PARA WITH TEST BEFORE UNTIL COUNT=5

PERFORM A-PARA WITH TEST AFTER UNTIL COUNT=5

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-CNT PIC 9(1) VALUE 0. 

PROCEDURE DIVISION.
   A-PARA.
   PERFORM B-PARA WITH TEST AFTER UNTIL WS-CNT>3.
   STOP RUN.
   
   B-PARA.
   DISPLAY 'WS-CNT : 'WS-CNT.
   ADD 1 TO WS-CNT.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-CNT : 0
WS-CNT : 1
WS-CNT : 2
WS-CNT : 3

Realizar tiempos

En 'tiempos de ejecución', un párrafo se ejecutará el número de veces especificado.

Sintaxis

A continuación se muestra la sintaxis de los tiempos de ejecución:

PERFORM A-PARA 5 TIMES.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

PROCEDURE DIVISION.
   A-PARA.
   PERFORM B-PARA 3 TIMES.
   STOP RUN.
   
   B-PARA.
   DISPLAY 'IN B-PARA'.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

IN B-PARA
IN B-PARA
IN B-PARA

Realizar variando

Al realizar la variación, se ejecutará un párrafo hasta que la condición en la frase Hasta que se convierta en verdadera.

Sintaxis

A continuación se muestra la sintaxis de realizar variando:

PERFORM A-PARA VARYING A FROM 1 BY 1 UNTIL A = 5.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-A PIC 9 VALUE 0.

PROCEDURE DIVISION.
   A-PARA.
   PERFORM B-PARA VARYING WS-A FROM 1 BY 1 UNTIL WS-A=5
   STOP RUN.
   
   B-PARA.
   DISPLAY 'IN B-PARA ' WS-A.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

IN B-PARA 1
IN B-PARA 2
IN B-PARA 3
IN B-PARA 4

IR A Declaración

La sentencia GO TO se utiliza para cambiar el flujo de ejecución en un programa. En las declaraciones GO TO, la transferencia solo se realiza en la dirección de avance. Se usa para salir de un párrafo. Los diferentes tipos de instrucciones GO TO que se utilizan son los siguientes:

Incondicional IR A

GO TO para-name.

Ir a condicional

GO TO para-1 para-2 para-3 DEPENDING ON x.

Si 'x' es igual a 1, entonces el control se transferirá al primer párrafo; y si 'x' es igual a 2, el control se transferirá al segundo párrafo, y así sucesivamente.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-A PIC 9 VALUE 2.
   
PROCEDURE DIVISION.
   A-PARA.
   DISPLAY 'IN A-PARA'
   GO TO B-PARA.
   
   B-PARA.
   DISPLAY 'IN B-PARA '.
   GO TO C-PARA D-PARA DEPENDING ON WS-A.
   
   C-PARA.
   DISPLAY 'IN C-PARA '.
   
   D-PARA.
   DISPLAY 'IN D-PARA '.
   STOP RUN.

JCL para ejecutar el programa COBOL anterior:

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

IN A-PARA
IN B-PARA 
IN D-PARA

Las declaraciones de manejo de cadenas en COBOL se utilizan para realizar múltiples operaciones funcionales en cadenas. A continuación se muestran las declaraciones de manejo de cadenas:

Inspect
String
Unstring

Inspeccionar

Inspeccionar verbo se usa para contar o reemplazar los caracteres en una cadena. Las operaciones de cadena se pueden realizar en valores alfanuméricos, numéricos o alfabéticos. Las operaciones de inspección se realizan de izquierda a derecha. Las opciones utilizadas para las operaciones de cadena son las siguientes:

Contando

La opción de conteo se usa para contar los caracteres de la cadena.

Syntax

A continuación se muestra la sintaxis de la opción Tallying:

INSPECT input-string
TALLYING output-count FOR ALL CHARACTERS

Los parámetros utilizados son:

input-string: la cadena cuyos caracteres se van a contar.
output-count: elemento de datos para contener el recuento de caracteres.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-CNT1 PIC 9(2) VALUE 0.
   01 WS-CNT2 PIC 9(2) VALUE 0.
   01 WS-STRING PIC X(15) VALUE 'ABCDACDADEAAAFF'.
   
PROCEDURE DIVISION.
   INSPECT WS-STRING TALLYING WS-CNT1 FOR CHARACTER.
   DISPLAY "WS-CNT1 : "WS-CNT1.
   INSPECT WS-STRING TALLYING WS-CNT2 FOR ALL 'A'.
   DISPLAY "WS-CNT2 : "WS-CNT2
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-CNT1 : 15
WS-CNT2 : 06

Reemplazo

La opción de reemplazo se utiliza para reemplazar los caracteres de cadena.

Syntax

A continuación se muestra la sintaxis de la opción Reemplazo:

INSPECT input-string REPLACING ALL char1 BY char2.

El parámetro utilizado es -

input-string - La cadena cuyos caracteres se reemplazarán de char1 a char2.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STRING PIC X(15) VALUE 'ABCDACDADEAAAFF'.

PROCEDURE DIVISION.
   DISPLAY "OLD STRING : "WS-STRING.
   INSPECT WS-STRING REPLACING ALL 'A' BY 'X'.
   DISPLAY "NEW STRING : "WS-STRING.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

OLD STRING : ABCDACDADEAAAFF
NEW STRING : XBCDXCDXDEXXXFF

Cuerda

El verbo de cadena se usa para concatenar las cadenas. Con la instrucción STRING, se pueden combinar dos o más cadenas de caracteres para formar una cadena más larga. La cláusula 'Delimitado por' es obligatoria.

Syntax

A continuación se muestra la sintaxis del verbo String:

STRING ws-string1 DELIMITED BY SPACE
   ws-string2 DELIMITED BY SIZE
   INTO ws-destination-string
   WITH POINTER ws-count
   ON OVERFLOW DISPLAY message1
   NOT ON OVERFLOW DISPLAY message2
END-STRING.

A continuación se muestran los detalles de los parámetros utilizados:

ws-string1 y ws-string2: cadenas de entrada para concatenar
ws-string: Cadena de salida
ws-count: se usa para contar la longitud de una nueva cadena concatenada
Delimitado especifica el final de la cadena
El puntero y el desbordamiento son opcionales

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STRING PIC A(30).
   01 WS-STR1 PIC A(15) VALUE 'Tutorialspoint'.
   01 WS-STR2 PIC A(7) VALUE 'Welcome'.
   01 WS-STR3 PIC A(7) VALUE 'To AND'.
   01 WS-COUNT PIC 99 VALUE 1.

PROCEDURE DIVISION.
   STRING WS-STR2 DELIMITED BY SIZE
      WS-STR3 DELIMITED BY SPACE
      WS-STR1 DELIMITED BY SIZE
      INTO WS-STRING 
      WITH POINTER WS-COUNT
      ON OVERFLOW DISPLAY 'OVERFLOW!' 
   END-STRING.
   
   DISPLAY 'WS-STRING : 'WS-STRING.
   DISPLAY 'WS-COUNT : 'WS-COUNT.

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-STRING : WelcomeToTutorialspoint       
WS-COUNT : 25

Desencadenado

El verbo sin cadena se usa para dividir una cadena en múltiples subcadenas. La cláusula delimitada por es obligatoria.

Syntax

A continuación se muestra la sintaxis del verbo Unstring:

UNSTRING ws-string DELIMITED BY SPACE
INTO ws-str1, ws-str2
WITH POINTER ws-count
ON OVERFLOW DISPLAY message
NOT ON OVERFLOW DISPLAY message
END-UNSTRING.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STRING PIC A(30) VALUE 'WELCOME TO TUTORIALSPOINT'.
   01 WS-STR1 PIC A(7).
   01 WS-STR2 PIC A(2).
   01 WS-STR3 PIC A(15).
   01 WS-COUNT PIC 99 VALUE 1.

PROCEDURE DIVISION.
   UNSTRING WS-STRING DELIMITED BY SPACE
      INTO WS-STR1, WS-STR2, WS-STR3
   END-UNSTRING.
   
   DISPLAY 'WS-STR1 : 'WS-STR1.
   DISPLAY 'WS-STR2 : 'WS-STR2.
   DISPLAY 'WS-STR3 : 'WS-STR3.
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-STR1 : WELCOME
WS-STR2 : TO
WS-STR3 : TUTORIALSPOINT

Las matrices en COBOL se conocen como tablas. Una matriz es una estructura de datos lineal y es una colección de elementos de datos individuales del mismo tipo. Los elementos de datos de una tabla se ordenan internamente.

Declaración de tabla

La tabla se declara en División de datos. OccursLa cláusula se utiliza para definir una tabla. La cláusula Ocurre indica la repetición de la definición del nombre de los datos. Solo se puede usar con números de nivel que comienzan del 02 al 49. La cláusula No usar ocurre con Redefine. La descripción de la tabla unidimensional y bidimensional es la siguiente:

Mesa unidimensional

En una tabla unidimensional, occursLa cláusula se usa solo una vez en la declaración. WSTABLE es el elemento de grupo que contiene la tabla. WS-B nombra los elementos de la tabla que ocurren 10 veces.

Syntax

A continuación se muestra la sintaxis para definir una tabla unidimensional:

01 WS-TABLE.
   05 WS-A PIC A(10) OCCURS 10 TIMES.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A PIC A(10) VALUE 'TUTORIALS' OCCURS 5 TIMES.     

PROCEDURE DIVISION.
   DISPLAY "ONE-D TABLE : "WS-TABLE.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

ONE-D TABLE : TUTORIALS TUTORIALS TUTORIALS TUTORIALS TUTORIALS

Mesa bidimensional

Se crea una tabla bidimensional con ambos elementos de datos de longitud variable. Como referencia, revise la sintaxis y luego intente analizar la tabla. La primera matriz (WS-A) puede ocurrir de 1 a 10 veces y la matriz interna (WS-C) puede ocurrir de 1 a 5 veces. Para cada entrada de WS-A, habrá 5 entradas correspondientes de WS-C.

Syntax

A continuación se muestra la sintaxis para definir una tabla bidimensional:

01 WS-TABLE.
   05 WS-A OCCURS 10 TIMES.
      10 WS-B PIC A(10).
      10 WS-C OCCURS 5 TIMES.
         15 WS-D PIC X(6).

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 2 TIMES.
         10 WS-B PIC A(10) VALUE ' TUTORIALS'.
         10 WS-C OCCURS 2 TIMES.
            15 WS-D PIC X(6) VALUE ' POINT'.

PROCEDURE DIVISION.
   DISPLAY "TWO-D TABLE : "WS-TABLE.

STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

TWO-D TABLE :  TUTORIALS POINT POINT TUTORIALS POINT POINT

Subíndice

Se puede acceder a los elementos individuales de la tabla utilizando subíndice. Los valores de subíndice pueden oscilar entre 1 y el número de veces que aparece la tabla. Un subíndice puede ser cualquier número positivo. No requiere ninguna declaración en la división de datos. Se crea automáticamente con la cláusula ocurre.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 3 TIMES.
         10 WS-B PIC A(2).
         10 WS-C OCCURS 2 TIMES.
            15 WS-D PIC X(3).

PROCEDURE DIVISION.
   MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
   DISPLAY 'WS-TABLE  : ' WS-TABLE.
   DISPLAY 'WS-A(1)   : ' WS-A(1).
   DISPLAY 'WS-C(1,1) : ' WS-C(1,1).
   DISPLAY 'WS-C(1,2) : ' WS-C(1,2).
   DISPLAY 'WS-A(2)   : ' WS-A(2).
   DISPLAY 'WS-C(2,1) : ' WS-C(2,1).
   DISPLAY 'WS-C(2,2) : ' WS-C(2,2).
   DISPLAY 'WS-A(3)   : ' WS-A(3).
   DISPLAY 'WS-C(3,1) : ' WS-C(3,1).
   DISPLAY 'WS-C(3,2) : ' WS-C(3,2).
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

WS-TABLE  : 12ABCDEF34GHIJKL56MNOPQR
WS-A(1)   : 12ABCDEF
WS-C(1,1) : ABC
WS-C(1,2) : DEF
WS-A(2)   : 34GHIJKL
WS-C(2,1) : GHI
WS-C(2,2) : JKL
WS-A(3)   : 56MNOPQR
WS-C(3,1) : MNO
WS-C(3,2) : PQR

Índice

También se puede acceder a los elementos de la tabla usando index. Un índice es un desplazamiento de un elemento desde el inicio de la tabla. Un índice se declara con la cláusula Occurs utilizando la cláusula INDEXED BY. El valor del índice se puede cambiar usando la instrucción SET y la opción PERFORM Varying.

Syntax

A continuación se muestra la sintaxis para definir el índice en una tabla:

01 WS-TABLE.
   05 WS-A PIC A(10) OCCURS 10 TIMES INDEXED BY I.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 3 TIMES INDEXED BY I.
         10 WS-B PIC A(2).
         10 WS-C OCCURS 2 TIMES INDEXED BY J.
            15 WS-D PIC X(3).

PROCEDURE DIVISION.
   MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
   PERFORM A-PARA VARYING I FROM 1 BY 1 UNTIL I >3 
   STOP RUN.
   
   A-PARA.
   PERFORM C-PARA VARYING J FROM 1 BY 1 UNTIL J>2.
   
   C-PARA.
   DISPLAY WS-C(I,J).

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

ABC
DEF
GHI
JKL
MNO
PQR

Establecer declaración

La instrucción Set se usa para cambiar el valor del índice. Set verb se usa para inicializar, incrementar o disminuir el valor del índice. Se utiliza con Buscar y Buscar todo para localizar elementos en la tabla.

Syntax

A continuación se muestra la sintaxis para usar una instrucción Set:

SET I J TO positive-number
SET I TO J
SET I TO 5
SET I J UP BY 1
SET J DOWN BY 5

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A OCCURS 3 TIMES INDEXED BY I.
         10 WS-B PIC A(2).
         10 WS-C OCCURS 2 TIMES INDEXED BY J.
            15 WS-D PIC X(3).

PROCEDURE DIVISION.
   MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
   SET I J TO 1.
   DISPLAY WS-C(I,J).
   SET I J UP BY 1.
   DISPLAY WS-C(I,J).
   
STOP RUN.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

ABC
JKL

Buscar

La búsqueda es un método de búsqueda lineal, que se utiliza para encontrar elementos dentro de la tabla. Se puede realizar tanto en una mesa clasificada como sin clasificar. Se usa solo para tablas declaradas por frase de índice. Comienza con el valor inicial de index. Si no se encuentra el elemento buscado, entonces el índice se incrementa automáticamente en 1 y continúa hasta el final de la tabla.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-A PIC X(1) OCCURS 18 TIMES INDEXED BY I.
   01 WS-SRCH PIC A(1) VALUE 'M'.

PROCEDURE DIVISION.
   MOVE 'ABCDEFGHIJKLMNOPQR' TO WS-TABLE.
   SET I TO 1.
   SEARCH WS-A
      AT END DISPLAY 'M NOT FOUND IN TABLE'
      WHEN WS-A(I) = WS-SRCH
      DISPLAY 'LETTER M FOUND IN TABLE'
   END-SEARCH.  

STOP RUN.

JCL para ejecutar el programa COBOL anterior.

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

LETTER M FOUND IN TABLE

Busca todo

Buscar todo es un método de búsqueda binaria, que se utiliza para buscar elementos dentro de la tabla. La tabla debe estar ordenada para la opción Buscar todo. El índice no requiere inicialización. En la búsqueda binaria, la tabla se divide en dos mitades y determina en qué mitad del elemento buscado está presente. Este proceso se repite hasta que se encuentra el elemento o se llega al final.

Example

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-TABLE.
      05 WS-RECORD OCCURS 10 TIMES ASCENDING KEY IS WS-NUM INDEXED BY I.
      10 WS-NUM PIC 9(2).
      10 WS-NAME PIC A(3).

PROCEDURE DIVISION.
   MOVE '12ABC56DEF34GHI78JKL93MNO11PQR' TO WS-TABLE.
   SEARCH ALL WS-RECORD
     AT END DISPLAY 'RECORD NOT FOUND'
     WHEN WS-NUM(I) = 93
     DISPLAY 'RECORD FOUND '
     DISPLAY WS-NUM(I)
     DISPLAY WS-NAME(I)

END-SEARCH.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

RECORD FOUND 
93
MNO

El concepto de archivos en COBOL es diferente al de C / C ++. Mientras aprende los conceptos básicos de 'Archivo' en COBOL, los conceptos de ambos idiomas no deben correlacionarse. Los archivos de texto simple no se pueden usar en COBOL, en su lugarPS (Physical Sequential) y VSAMse utilizan archivos. Los archivos PS se discutirán en este módulo.

Para comprender el manejo de archivos en COBOL, es necesario conocer los términos básicos. Estos términos solo sirven para comprender los fundamentos del manejo de archivos. La terminología más detallada se tratará en el capítulo "Verbos de manejo de archivos". Los siguientes son los términos básicos:

Field
Record
Registro físico
Registro lógico
File

El siguiente ejemplo ayuda a comprender estos términos:

Campo

El campo se utiliza para indicar los datos almacenados sobre un elemento. Representa un solo elemento como se muestra en el ejemplo anterior, como la identificación del estudiante, el nombre, las calificaciones, las calificaciones totales y el porcentaje. La cantidad de caracteres en cualquier campo se conoce como tamaño de campo, por ejemplo, el nombre del estudiante puede tener 10 caracteres. Los campos pueden tener los siguientes atributos:

Primary keysson aquellos campos que son únicos para cada registro y se utilizan para identificar un registro en particular. Por ejemplo, en el archivo de calificaciones de los estudiantes, cada estudiante tendrá una identificación de estudiante única que forma la clave principal.
Secondary keysson campos únicos o no únicos que se utilizan para buscar datos relacionados. Por ejemplo, en el archivo de calificaciones de los estudiantes, el nombre completo del estudiante se puede utilizar como clave secundaria cuando se desconoce la identificación del estudiante.
DescriptorsLos campos se utilizan para describir una entidad. Por ejemplo, en el archivo de calificaciones de los estudiantes, las calificaciones y los campos de porcentaje que agregan significado al registro son descriptores conocidos.

Grabar

El registro es una colección de campos que se usa para describir una entidad. Uno o más campos juntos forman un registro. Por ejemplo, en el archivo de calificaciones de los estudiantes, la identificación del estudiante, el nombre, las calificaciones, las calificaciones totales y el porcentaje forman un registro. El tamaño acumulativo de todos los campos de un registro se conoce como tamaño de registro. Los registros presentes en un archivo pueden ser de longitud fija o variable.

Registro físico

El registro físico es la información que existe en el dispositivo externo. También se conoce como bloque.

Registro lógico

El registro lógico es la información utilizada por el programa. En los programas COBOL, solo se puede manejar un registro en cualquier momento y se llama registro lógico.

Archivo

El archivo es una colección de registros relacionados. Por ejemplo, el archivo de calificaciones de los estudiantes consta de registros de todos los estudiantes.

La organización de archivos indica cómo se organizan los registros en un archivo. Existen diferentes tipos de organizaciones de archivos con el fin de aumentar su eficiencia en el acceso a los registros. A continuación se muestran los tipos de esquemas de organización de archivos:

Organización secuencial de archivos
Organización de archivos secuenciales indexados
Organización de archivos relativa

Las sintaxis en este módulo, mencionadas junto con sus respectivos términos, solo se refieren a su uso en el programa. Los programas completos que utilizan estas sintaxis se discutirán en el capítulo 'Verbos de manejo de archivos'.

Organización secuencial de archivos

Un archivo secuencial consta de registros que se almacenan y se accede a ellos en orden secuencial. Los siguientes son los atributos clave de la organización secuencial de archivos:

Los registros se pueden leer en orden secuencial. Para leer el ^décimo registro, se deben leer todos los 9 registros anteriores.
Los registros se escriben en orden secuencial. No se puede insertar un nuevo registro en el medio. Siempre se inserta un nuevo registro al final del archivo.
Después de colocar un registro en un archivo secuencial, no es posible eliminar, acortar o alargar un registro.
El orden de los registros, una vez insertados, nunca se puede cambiar.
Es posible actualizar el registro. Un registro se puede sobrescribir si la longitud del nuevo registro es la misma que la del antiguo.
Los archivos de salida secuenciales son una buena opción para imprimir.

Sintaxis

A continuación se muestra la sintaxis de la organización secuencial de archivos:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name-jcl
   ORGANIZATION IS SEQUENTIAL

Organización de archivos secuenciales indexados

Un archivo secuencial indexado consta de registros a los que se puede acceder de forma secuencial. También es posible el acceso directo. Consta de dos partes:

Data File contiene registros en esquema secuencial.
Index File contiene la clave principal y su dirección en el archivo de datos.

Los siguientes son los atributos clave de la organización secuencial de archivos:

Los registros se pueden leer en orden secuencial al igual que en la organización de archivos secuenciales.
Se puede acceder a los registros de forma aleatoria si se conoce la clave principal. El archivo de índice se utiliza para obtener la dirección de un registro y luego el registro se obtiene del archivo de datos.
El índice ordenado se mantiene en este sistema de archivos que relaciona el valor clave con la posición del registro en el archivo.
También se puede crear un índice alternativo para recuperar los registros.

Sintaxis

A continuación se muestra la sintaxis de la organización de archivos secuenciales indexados:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name-jcl
   ORGANIZATION IS INDEXED
   RECORD KEY IS primary-key
   ALTERNATE RECORD KEY IS rec-key

Organización de archivos relativa

Un archivo relativo consta de registros ordenados por su relative address. Los siguientes son los atributos clave de la organización relativa de archivos:

Los registros se pueden leer en orden secuencial al igual que en la organización de archivos secuenciales e indexados.
Se puede acceder a los registros usando la clave relativa. La clave relativa representa la ubicación del registro en relación con la dirección de inicio del archivo.
Los registros se pueden insertar usando la clave relativa. La dirección relativa se calcula utilizando la clave relativa.
El archivo relativo proporciona el acceso más rápido a los registros.
La principal desventaja de este sistema de archivos es que si faltan algunos registros intermedios, también ocuparán espacio.

Sintaxis

A continuación se muestra la sintaxis de la organización relativa de archivos:

INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name-jcl
   ORGANIZATION IS RELATIVE
   RELATIVE KEY IS rec-key

Hasta ahora, se han discutido esquemas de organización de archivos. Para cada esquema de organización de archivos, se pueden utilizar diferentes modos de acceso. A continuación se muestran los tipos de modos de acceso a archivos:

Acceso secuencial
Acceso aleatorio
Acceso dinámico

Acceso secuencial

Cuando el modo de acceso es secuencial, el método de recuperación de registros cambia según la organización de archivos seleccionada.

por sequential files, se accede a los registros en el mismo orden en que se insertaron.
por indexed files, el parámetro utilizado para recuperar los registros son los valores de clave de registro.
por relative files, las claves de registro relativas se utilizan para recuperar los registros.

Sintaxis

A continuación se muestra la sintaxis del modo de acceso secuencial:

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS SEQUENTIAL
   ACCESS MODE IS SEQUENTIAL
	
	
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS INDEXED
   ACCESS MODE IS SEQUENTIAL
   RECORD KEY IS rec-key1
   ALTERNATE RECORD KEY IS rec-key2

		
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS RELATIVE
   ACCESS MODE IS SEQUENTIAL
   RELATIVE KEY IS rec-key1

Acceso aleatorio

Cuando el modo de acceso es ALEATORIO, el método de recuperación de registros cambia según la organización de archivos seleccionada.

por indexed files, se accede a los registros de acuerdo con el valor colocado en un campo de clave que puede ser clave principal o alternativa. Puede haber uno o más índices alternativos.
por relative files , los registros se recuperan mediante claves de registro relativas.

Sintaxis

A continuación se muestra la sintaxis del modo de acceso aleatorio:

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS INDEXED
   ACCESS MODE IS RANDOM
   RECORD KEY IS rec-key1
   ALTERNATE RECORD KEY IS rec-key2

		
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS RELATIVE
   ACCESS MODE IS RANDOM
   RELATIVE KEY IS rec-key1

Acceso dinámico

El acceso dinámico admite acceso secuencial y aleatorio en el mismo programa. Con el acceso dinámico, se utiliza una definición de archivo para realizar un procesamiento secuencial y aleatorio, como acceder a algunos registros en orden secuencial y a otros registros por sus claves.

Con archivos relativos e indexados, el modo de acceso dinámico le permite alternar entre el modo de acceso secuencial y el modo de acceso aleatorio mientras lee un archivo usando la frase NEXT en la instrucción READ. Las funcionalidades NEXT y READ se discutirán en el próximo capítulo.

Sintaxis

A continuación se muestra la sintaxis del modo de acceso dinámico:

ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS SEQUENTIAL
   ACCESS MODE IS DYNAMIC
   RECORD KEY IS rec-key1
   ALTERNATE RECORD KEY IS rec-key2

		
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT file-name ASSIGN TO dd-name
   ORGANIZATION IS RELATIVE
   ACCESS MODE IS DYNAMIC
   RELATIVE KEY IS rec-key1

Los verbos de manejo de archivos se utilizan para realizar varias operaciones en archivos. A continuación se muestran los verbos de manejo de archivos:

Open
Read
Write
Rewrite
Delete
Start
Close

Verbo abierto

Abrir es la primera operación de archivo que se debe realizar. Si Abrir tiene éxito, solo se pueden realizar más operaciones en un archivo. Solo después de abrir un archivo, las variables de la estructura del archivo están disponibles para su procesamiento.FILE STATUS La variable se actualiza después de cada operación de archivo.

Sintaxis

OPEN "mode" file-name.

Aquí, file-name es una cadena literal, que usará para nombrar su archivo. Un archivo se puede abrir en los siguientes modos:

No Señor.	Modo y descripción
1	Input El modo de entrada se utiliza para archivos existentes. En este modo, solo podemos leer el archivo, no se permiten otras operaciones en el archivo.
2	Output El modo de salida se utiliza para insertar registros en archivos. Si unsequential filese utiliza y el archivo contiene algunos registros, luego los registros existentes se eliminarán primero y luego se insertarán nuevos registros en el archivo. No sucederá así en caso deindexed file o un relative file.
3	Extend El modo extendido se usa para agregar registros en un sequential file. En este modo, los registros se insertan al final. Si el modo de acceso a archivos esRandom o Dynamic, entonces no se puede utilizar el modo extendido.
4	I-O El modo Entrada-Salida se utiliza para leer y reescribir los registros de un archivo.

Leer Verbo

Leer verbo se utiliza para leer los registros de archivos. La función de lectura es buscar registros de un archivo. En cada verbo leído, solo se puede leer un registro en la estructura del archivo. Para realizar una operación de lectura, abra el archivo en modo INPUT o IO. En cada instrucción de lectura, el puntero de archivo se incrementa y, por lo tanto, se leen los registros sucesivos.

Sintaxis

A continuación se muestra la sintaxis para leer los registros cuando el modo de acceso a archivos es secuencial:

READ file-name NEXT RECORD INTO ws-file-structure
   AT END DISPLAY 'End of File'
   NOT AT END DISPLAY 'Record Details:' ws-file-structure
END-READ.

A continuación se muestran los parámetros utilizados:

NEXT RECORD es opcional y se especifica cuando un archivo secuencial indexado se lee de forma secuencial.
La cláusula INTO es opcional. ws-file-structure se define en la sección WorkingStorage para obtener los valores de la instrucción READ.
La condición AT END se convierte en True cuando se alcanza el final del archivo.

Example- El siguiente ejemplo lee un archivo existente usando una organización secuencial de líneas. Este programa se puede compilar y ejecutar utilizandoLive Demo opción donde mostrará todos los registros presentes en el archivo.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
      FILE-CONTROL.
      SELECT STUDENT ASSIGN TO 'input.txt'
      ORGANIZATION IS LINE SEQUENTIAL.            

DATA DIVISION.
   FILE SECTION.
   FD STUDENT.
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(5).
      05 NAME PIC A(25).

   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
   01 WS-EOF PIC A(1). 

PROCEDURE DIVISION.
   OPEN INPUT STUDENT.
      PERFORM UNTIL WS-EOF='Y'
         READ STUDENT INTO WS-STUDENT
            AT END MOVE 'Y' TO WS-EOF
            NOT AT END DISPLAY WS-STUDENT
         END-READ
      END-PERFORM.
   CLOSE STUDENT.
STOP RUN.

Suponga que los datos del archivo de entrada disponibles en el input.txt El archivo contiene lo siguiente:

20003 Mohtashim M.
20004 Nishant Malik
20005 Amitabh Bachhan

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

20003 Mohtashim M.            
20004 Nishant Malik           
20005 Amitabh Bachhan

Sintaxis

A continuación se muestra la sintaxis para leer un registro cuando el modo de acceso a archivos es aleatorio:

READ file-name RECORD INTO ws-file-structure
   KEY IS rec-key
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Details: ' ws-file-structure
END-READ.

Example- El siguiente ejemplo lee un archivo existente usando una organización indexada. Este programa se puede compilar y ejecutar utilizandoJCLen Mainframes donde mostrará todos los registros presentes en el archivo. En el servidor Mainframes, no utilizamos archivos de texto; en su lugar usamos archivos PS.

Supongamos que el archivo presente en Mainframes tiene el mismo contenido que el archivo input.txt en el ejemplo anterior.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO IN1
      ORGANIZATION IS INDEXED
      ACCESS IS RANDOM
      RECORD KEY IS STUDENT-ID
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT.
      01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(5).
      05 NAME PIC A(25).
     
   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).

PROCEDURE DIVISION.
   OPEN INPUT STUDENT.
      MOVE 20005 TO STUDENT-ID.
      
      READ STUDENT RECORD INTO WS-STUDENT-FILE
         KEY IS STUDENT-ID
         INVALID KEY DISPLAY 'Invalid Key'
         NOT INVALID KEY DISPLAY WS-STUDENT-FILE
      END-READ.
      
   CLOSE STUDENT.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN = STUDENT-FILE-NAME,DISP=SHR

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

20005 Amitabh Bachhan

Escribir verbo

El verbo escribir se usa para insertar registros en un archivo. Una vez que se escribe el registro, ya no está disponible en el búfer de registro. Antes de insertar registros en el archivo, mueva los valores al búfer de registros y luego realice la escritura del verbo.

La declaración de escritura se puede usar con FROMopción para escribir registros directamente desde las variables de almacenamiento de trabajo. From es una cláusula opcional. Si el modo de acceso es secuencial, para escribir un registro, el archivo debe abrirse en el modo de salida o extendido. Si el modo de acceso es aleatorio o dinámico, para escribir un registro, el archivo debe abrirse en modo Salida o modo IO.

Sintaxis

A continuación se muestra la sintaxis para leer un registro cuando la organización del archivo es secuencial:

WRITE record-buffer [FROM ws-file-structure]
END-WRITE.

A continuación se muestra la sintaxis para leer un registro cuando la organización del archivo está indexada o es relativa:

WRITE record-buffer [FROM ws-file-structure]
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Inserted'
END-WRITE.

Example - El siguiente ejemplo muestra cómo insertar un nuevo registro en un nuevo archivo cuando la organización es secuencial.

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO OUT1
      ORGANIZATION IS SEQUENTIAL
      ACCESS IS SEQUENTIAL
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(5).
      05 NAME PIC A(25).
      05 CLASS PIC X(3).

   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
      05 WS-CLASS PIC X(3).

PROCEDURE DIVISION.
   OPEN EXTEND STUDENT.
      MOVE 1000 TO STUDENT-ID.
      MOVE 'Tim' TO NAME.
      MOVE '10' TO CLASS.
      WRITE STUDENT-FILE
      END-WRITE.	
   CLOSE STUDENT.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//OUT1 DD DSN = OUTPUT-FILE-NAME,DISP = (NEW,CATALOG,DELETE)

Cuando compile y ejecute el programa anterior, agregará un nuevo registro al archivo de salida.

1000 Tim         10

Reescribir el verbo

El verbo reescribir se usa para actualizar los registros. El archivo debe abrirse en modo IO para operaciones de reescritura. Solo se puede usar después de una operación de lectura exitosa. El verbo reescribir sobrescribe el último registro leído.

Sintaxis

A continuación se muestra la sintaxis para leer un registro cuando la organización del archivo es secuencial:

REWRITE record-buffer [FROM ws-file-structure]
END-REWRITE.

A continuación se muestra la sintaxis para leer un registro cuando la organización del archivo está indexada o es relativa:

REWRITE record-buffer [FROM ws-file-structure]
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Updated'
END-REWRITE.

Example - El siguiente ejemplo muestra cómo actualizar un registro existente que hemos insertado en el paso anterior de Escritura -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO IN1
      ORGANIZATION IS INDEXED
      ACCESS IS RANDOM
      RECORD KEY IS STUDENT-ID
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(4).
      05 NAME PIC A(12).
      05 CLASS PIC X(3).
      
   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
      05 WS-CLASS PIC X(3).

PROCEDURE DIVISION.
   OPEN I-O STUDENT.
   MOVE '1000' TO STUDENT-ID.
  
   READ STUDENT
      KEY IS STUDENT-ID
      INVALID KEY DISPLAY ‘KEY IS NOT EXISTING’
   END-READ.
  
   MOVE 'Tim Dumais' TO NAME.
   REWRITE STUDENT-FILE
   END-REWRITE.
   CLOSE STUDENT.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN = OUTPUT-FILE-NAME,DISP = SHR

Cuando compile y ejecute el programa anterior, actualizará el registro:

1000 Tim Dumais  10

Eliminar verbo

Eliminar verbo solo se puede realizar en archivos indexados y relativos. El archivo debe abrirse en modo IO. En la organización de archivos secuenciales, los registros no se pueden eliminar. El registro leído por última vez por la instrucción de lectura se elimina en el caso del modo de acceso secuencial. En el modo de acceso aleatorio, especifique la clave de registro y luego realice la operación Eliminar.

Sintaxis

A continuación se muestra la sintaxis para eliminar un registro:

DELETE file-name RECORD
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'Record Deleted'
END-DELETE.

Example - para eliminar un registro existente -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
   SELECT STUDENT ASSIGN TO OUT1
      ORGANIZATION IS INDEXED
      ACCESS IS RANDOM
      RECORD KEY IS STUDENT-ID
      FILE STATUS IS FS.

DATA DIVISION.
   FILE SECTION.
   FD STUDENT
   01 STUDENT-FILE.
      05 STUDENT-ID PIC 9(4).
      05 NAME PIC A(12).
      05 CLASS PIC X(3).
   WORKING-STORAGE SECTION.
   01 WS-STUDENT.
      05 WS-STUDENT-ID PIC 9(5).
      05 WS-NAME PIC A(25).
      05 WS-CLASS PIC X(3).

PROCEDURE DIVISION.
   OPEN I-O STUDENT.
   MOVE '1000' TO STUDENT-ID.
   
   DELETE STUDENT RECORD
      INVALID KEY DISPLAY 'Invalid Key'
      NOT INVALID KEY DISPLAY 'Record Deleted'
   END-DELETE.
   
   CLOSE STUDENT.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//OUT1 DD DSN = OUTPUT-FILE-NAME,DISP = SHR

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Record Deleted

Verbo de inicio

El verbo de inicio solo se puede ejecutar en archivos indexados y relativos. Se utiliza para colocar el puntero del archivo en un registro específico. El modo de acceso debe ser secuencial o dinámico. El archivo debe abrirse en modo IO o Input.

Sintaxis

A continuación se muestra la sintaxis para colocar el puntero en un registro específico:

START file-name KEY IS [=, >, <, NOT, <= or >=] rec-key
   INVALID KEY DISPLAY 'Invalid Key'
   NOT INVALID KEY DISPLAY 'File Pointer Updated'
END-START.

Cerrar Verbo

El verbo cerrar se usa para cerrar un archivo. Después de realizar la operación Cerrar, las variables en la estructura del archivo no estarán disponibles para su procesamiento. Se pierde el vínculo entre el programa y el archivo.

Sintaxis

A continuación se muestra la sintaxis para cerrar un archivo:

CLOSE file-name.

La subrutina Cobol es un programa que se puede compilar de forma independiente pero no se puede ejecutar de forma independiente. Hay dos tipos de subrutinas:internal subroutines me gusta Perform declaraciones y external subrutinas como el verbo CALL.

Verbo de llamada

El verbo de llamada se utiliza para transferir el control de un programa a otro. El programa que contiene el verbo CALL es elCalling Program y el programa que se llama se conoce como Called Program. La ejecución del programa llamado se detendrá hasta que el programa llamado finalice la ejecución. La instrucción Salir del programa se utiliza en el programa Llamado para transferir el control de vuelta.

Restricciones del programa llamado

Los siguientes son los requisitos del programa llamado:

Linkage sectiondebe estar definido en el programa llamado. Consiste en elementos de datos pasados en el programa. Los elementos de datos no deben tener una cláusula de valor. La cláusula PIC debe ser compatible con las variables pasadas a través del programa de llamada.
Procedure division using tiene una lista de variables pasadas desde el programa de llamada y el orden debe ser el mismo que se menciona en el verbo de llamada.
Exit programLa instrucción se usa en el programa llamado para transferir el control de vuelta. Debe ser la última declaración del programa llamado.

Los parámetros se pueden pasar entre programas de dos formas:

Por referencia
Por contenido

Llamar por referencia

Si se modifican los valores de las variables en el programa llamado, entonces sus nuevos valores se reflejarán en el programa de llamada. SiBY no se especifica una cláusula, entonces las variables siempre se pasan por referencia.

Sintaxis

A continuación se muestra la sintaxis de llamar a la subrutina por referencia:

CALL sub-prog-name USING variable-1, variable-2.

Example

El siguiente ejemplo es el programa de llamada MAIN y UTIL es el programa llamado -

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STUDENT-ID PIC 9(4) VALUE 1000.
   01 WS-STUDENT-NAME PIC A(15) VALUE 'Tim'.

PROCEDURE DIVISION.
   CALL 'UTIL' USING WS-STUDENT-ID, WS-STUDENT-NAME.
   DISPLAY 'Student Id : ' WS-STUDENT-ID
   DISPLAY 'Student Name : ' WS-STUDENT-NAME
STOP RUN.

Programa llamado

IDENTIFICATION DIVISION.
PROGRAM-ID. UTIL.

DATA DIVISION.
   LINKAGE SECTION.
   01 LS-STUDENT-ID PIC 9(4).
   01 LS-STUDENT-NAME PIC A(15).

PROCEDURE DIVISION USING LS-STUDENT-ID, LS-STUDENT-NAME.
   DISPLAY 'In Called Program'.
   MOVE 1111 TO LS-STUDENT-ID.
EXIT PROGRAM.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = MAIN

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

In Called Program
Student Id : 1111
Student Name : Tim

Llamar por contenido

Si se modifican los valores de las variables en el programa llamado, entonces sus nuevos valores no se reflejarán en el programa de llamada.

Sintaxis

A continuación se muestra la sintaxis de llamar a la subrutina por contenido:

CALL sub-prog-name USING 
BY CONTENT variable-1, BY CONTENT variable-2.

Example

El siguiente ejemplo es el programa de llamada MAIN y UTIL es el programa llamado -

IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   01 WS-STUDENT-ID PIC 9(4) VALUE 1000.
   01 WS-STUDENT-NAME PIC A(15) VALUE 'Tim'.

PROCEDURE DIVISION.
   CALL 'UTIL' USING BY CONTENT WS-STUDENT-ID, BY CONTENT WS-STUDENT-NAME.
   DISPLAY 'Student Id : ' WS-STUDENT-ID
   DISPLAY 'Student Name : ' WS-STUDENT-NAME
STOP RUN.

Programa llamado

IDENTIFICATION DIVISION.
PROGRAM-ID. UTIL.

DATA DIVISION.
   LINKAGE SECTION.
   01 LS-STUDENT-ID PIC 9(4).
   01 LS-STUDENT-NAME PIC A(15).

PROCEDURE DIVISION USING LS-STUDENT-ID, LS-STUDENT-NAME.
   DISPLAY 'In Called Program'.
   MOVE 1111 TO LS-STUDENT-ID.
EXIT PROGRAM.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = MAIN

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

In Called Program
Student Id : 1000
Student Name : Tim

Tipos de llamada

Hay dos tipos de llamadas:

Static Callocurre cuando un programa se compila con la opción del compilador NODYNAM. Un programa llamado estático se carga en el almacenamiento durante la compilación.
Dynamic Callocurre cuando un programa se compila con la opción del compilador DYNAM y NODLL. Un programa llamado dinámico se carga en el almacenamiento en tiempo de ejecución.

La clasificación de datos en un archivo o la combinación de dos o más archivos es una necesidad común en casi todas las aplicaciones orientadas a los negocios. La clasificación se utiliza para organizar los registros en orden ascendente o descendente, de modo que se pueda realizar el procesamiento secuencial. Hay dos técnicas que se utilizan para ordenar archivos en COBOL:

External sortse utiliza para ordenar archivos mediante la utilidad SORT en JCL. Hemos hablado de esto en el capítulo JCL. A partir de ahora, nos centraremos en la clasificación interna.
Internal sort se utiliza para ordenar archivos dentro de un programa COBOL. SORT verbo se utiliza para ordenar un archivo.

Ordenar verbo

Se utilizan tres archivos en el proceso de clasificación en COBOL:

Input file es el archivo que tenemos que ordenar en orden ascendente o descendente.
Work filese utiliza para mantener registros mientras el proceso de clasificación está en curso. Los registros del archivo de entrada se transfieren al archivo de trabajo para el proceso de clasificación. Este archivo debe definirse en la sección Archivo en la entrada SD.
Output filees el archivo que obtenemos después del proceso de clasificación. Es la salida final del verbo Sort.

Sintaxis

A continuación se muestra la sintaxis para ordenar un archivo:

SORT work-file ON ASCENDING KEY rec-key1
   [ON DESCENDING KEY rec-key2]
USING input-file GIVING output-file.

SORT realiza las siguientes operaciones:

Abre archivo de trabajo en modo IO, archivo de entrada en modo INPUT y archivo de salida en modo OUTPUT.

Transfiere los registros presentes en el archivo de entrada al archivo de trabajo.

Ordena el SORT-FILE en secuencia ascendente / descendente por tecla rec.

Transfiere los registros ordenados del archivo de trabajo al archivo de salida.

Cierra el archivo de entrada y el archivo de salida y elimina el archivo de trabajo.

Example

En el siguiente ejemplo, INPUT es el archivo de entrada que debe ordenarse en orden ascendente:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
      SELECT INPUT ASSIGN TO IN.
      SELECT OUTPUT ASSIGN TO OUT.
      SELECT WORK ASSIGN TO WRK.

DATA DIVISION.
   FILE SECTION.
   FD INPUT.
      01 INPUT-STUDENT.
         05 STUDENT-ID-I PIC 9(5).
         05 STUDENT-NAME-I PIC A(25).
   FD OUTPUT.
      01 OUTPUT-STUDENT.
         05 STUDENT-ID-O PIC 9(5).
         05 STUDENT-NAME-O PIC A(25).
   SD WORK.
      01 WORK-STUDENT.
         05 STUDENT-ID-W PIC 9(5).
         05 STUDENT-NAME-W PIC A(25).

PROCEDURE DIVISION.
   SORT WORK ON ASCENDING KEY STUDENT-ID-O
   USING INPUT GIVING OUTPUT.
   DISPLAY 'Sort Successful'.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN DD DSN = INPUT-FILE-NAME,DISP = SHR
//OUT DD DSN = OUTPUT-FILE-NAME,DISP = SHR
//WRK DD DSN = &&TEMP

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Sort Successful

Fusionar verbo

Se combinan dos o más archivos secuenciados de forma idéntica mediante la instrucción Merge. Archivos utilizados en el proceso de combinación:

Archivos de entrada: Entrada-1, Entrada-2
Archivo de trabajo
Archivo de salida

Sintaxis

A continuación se muestra la sintaxis para fusionar dos o más archivos:

MERGE work-file ON ASCENDING KEY rec-key1
   [ON DESCENDING KEY rec-key2]

USING input-1, input-2 GIVING output-file.

Merge realiza las siguientes operaciones:

Abre el archivo de trabajo en el modo IO, los archivos de entrada en el modo INPUT y el archivo de salida en el modo OUTPUT.

Transfiere los registros presentes en los archivos de entrada al archivo de trabajo.

Ordena el SORT-FILE en secuencia ascendente / descendente por tecla rec.

Transfiere los registros ordenados del archivo de trabajo al archivo de salida.

Cierra el archivo de entrada y el archivo de salida y elimina el archivo de trabajo.

Example

En el siguiente ejemplo, INPUT1 e INPUT2 son los archivos de entrada que se fusionarán en orden ascendente:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
      SELECT INPUT1 ASSIGN TO IN1.
      SELECT INPUT2 ASSIGN TO IN2.
      SELECT OUTPUT ASSIGN TO OUT.
      SELECT WORK ASSIGN TO WRK.

DATA DIVISION.
   FILE SECTION.
   FD INPUT1.
      01 INPUT1-STUDENT.
         05 STUDENT-ID-I1 PIC 9(5).
         05 STUDENT-NAME-I1 PIC A(25).
   FD INPUT2.
      01 INPUT2-STUDENT.
         05 STUDENT-ID-I2 PIC 9(5).
         05 STUDENT-NAME-I2 PIC A(25).
   FD OUTPUT.
      01 OUTPUT-STUDENT.
         05 STUDENT-ID-O PIC 9(5).
         05 STUDENT-NAME-O PIC A(25).
   SD WORK.
      01 WORK-STUDENT.
         05 STUDENT-ID-W PIC 9(5).
         05 STUDENT-NAME-W PIC A(25).

PROCEDURE DIVISION.
   MERGE WORK ON ASCENDING KEY STUDENT-ID-O
   USING INPUT1, INPUT2 GIVING OUTPUT.
   DISPLAY 'Merge Successful'.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN=INPUT1-FILE-NAME,DISP=SHR
//IN2 DD DSN=INPUT2-FILE-NAME,DISP=SHR
//OUT DD DSN = OUTPUT-FILE-NAME,DISP=SHR
//WRK DD DSN = &&TEMP

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Merge Successful

A partir de ahora, hemos aprendido el uso de archivos en COBOL. Ahora, discutiremos cómo interactúa un programa COBOL con DB2. Implica los siguientes términos:

SQL incorporado
Programación de aplicaciones DB2
Variables de host
SQLCA
Consultas SQL
Cursors

SQL incorporado

Las sentencias de SQL incorporado se utilizan en los programas COBOL para realizar operaciones de SQL estándar. El procesador de SQL procesa previamente las sentencias de SQL incorporado antes de que se compile el programa de aplicación. COBOL se conoce como elHost Language. Las aplicaciones COBOL-DB2 son aquellas aplicaciones que incluyen tanto COBOL como DB2.

Las sentencias SQL incorporadas funcionan como sentencias SQL normales con algunos cambios menores. Por ejemplo, la salida de una consulta se dirige a un conjunto predefinido de variables que se denominanHost Variables. Se coloca una cláusula INTO adicional en la instrucción SELECT.

Programación de aplicaciones DB2

Las siguientes son las reglas que se deben seguir al codificar un programa COBOL-DB2:

Todas las sentencias SQL deben estar delimitadas entre EXEC SQL y ENDEXEC..
Las sentencias SQL deben codificarse en el Área B.
Todas las tablas que se utilizan en un programa deben declararse en la sección WorkingStorage. Esto se hace usando elINCLUDE declaración.
Todas las sentencias SQL distintas de INCLUDE y DECLARE TABLE deben aparecer en la División de procedimientos.

Variables de host

Las variables de host se utilizan para recibir datos de una tabla o insertar datos en una tabla. Las variables del host deben declararse para todos los valores que se van a pasar entre el programa y DB2. Se declaran en la Sección Trabajo-Almacenamiento.

Las variables del host no pueden ser elementos de grupo, pero pueden agruparse en la estructura del host. Ellos no pueden serRenamed o Redefined. Utilizando variables del lenguaje principal con sentencias SQL, anteponga uncolon (:)..

Sintaxis

A continuación se muestra la sintaxis para declarar variables del lenguaje principal e incluir tablas en la sección Almacenamiento de trabajo:

DATA DIVISION.
   WORKING-STORAGE SECTION.
   
   EXEC SQL
   INCLUDE table-name
   END-EXEC.

   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
   
   01 STUDENT-REC.
      05 STUDENT-ID PIC 9(4).
      05 STUDENT-NAME PIC X(25).
      05 STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

SQLCA

SQLCA es un área de comunicación de SQL a través de la cual DB2 pasa la retroalimentación de la ejecución de SQL al programa. Le dice al programa si una ejecución fue exitosa o no. Hay una serie de variables predefinidas en SQLCA comoSQLCODEque contiene el código de error. El valor '000' en SQLCODE indica una ejecución exitosa.

Sintaxis

A continuación se muestra la sintaxis para declarar un SQLCA en la sección Working-Storage:

DATA DIVISION.
WORKING-STORAGE SECTION.
	EXEC SQL
	INCLUDE SQLCA
	END-EXEC.

Consultas SQL

Supongamos que tenemos una tabla llamada 'Estudiante' que contiene Id. De estudiante, Nombre de estudiante y Dirección de estudiante.

La tabla ESTUDIANTE contiene los siguientes datos:

Student Id		Student Name		Student Address
1001 			   Mohtashim M.		Hyderabad
1002			   Nishant Malik		Delhi
1003 			   Amitabh Bachan		Mumbai
1004			   Chulbul Pandey		Lucknow

El siguiente ejemplo muestra el uso de SELECT consulta en un programa COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   EXEC SQL
      INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
      INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   EXEC SQL
      SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS
      INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS FROM STUDENT
      WHERE STUDENT-ID=1004
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY WS-STUDENT-RECORD
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

1004 Chulbul Pandey		Lucknow

El siguiente ejemplo muestra el uso de INSERT consulta en un programa COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 1005 TO WS-STUDENT-ID.
   MOVE 'TutorialsPoint' TO WS-STUDENT-NAME.
   MOVE 'Hyderabad' TO WS-STUDENT-ADDRESS.
   
   EXEC SQL
      INSERT INTO STUDENT(STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS)
      VALUES (:WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS)
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY 'Record Inserted Successfully'
      DISPLAY WS-STUDENT-REC
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT   DD SYSOUT = *
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Record Inserted Successfully
1005 TutorialsPoint		Hyderabad

El siguiente ejemplo muestra el uso de UPDATE consulta en un programa COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   
   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 'Bangalore' TO WS-STUDENT-ADDRESS.
   EXEC SQL
      UPDATE STUDENT SET STUDENT-ADDRESS=:WS-STUDENT-ADDRESS
      WHERE STUDENT-ID = 1003
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY 'Record Updated Successfully'
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT   DD SYSOUT = *
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Record Updated Successfully

El seguimiento example muestra el uso de DELETE consulta en un programa COBOL -

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
WORKING-STORAGE SECTION.

   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 1005 TO WS-STUDENT-ID.
   
   EXEC SQL
      DELETE FROM STUDENT
      WHERE STUDENT-ID=:WS-STUDENT-ID
   END-EXEC.
   
   IF SQLCODE = 0 
      DISPLAY 'Record Deleted Successfully'
   ELSE DISPLAY 'Error'
   END-IF.
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM = IKJEFT01
//STEPLIB  DD DSN = MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT   DD SYSOUT = *
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

Record Deleted Successfully

Cursores

Los cursores se utilizan para gestionar varias selecciones de filas a la vez. Son estructuras de datos que contienen todos los resultados de una consulta. Se pueden definir en la Sección Trabajo-Almacenamiento o en la División de Procedimientos. Las siguientes son las operaciones asociadas con Cursor:

Declare
Open
Close
Fetch

Declarar cursor

La declaración del cursor se puede hacer en la Sección de Trabajo-Almacenamiento o en la División de Procedimientos. La primera declaración es la declaración DECLARE, que es una declaración no ejecutable.

EXEC SQL
   DECLARE STUDCUR CURSOR FOR
   SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS FROM STUDENT
   WHERE STUDENT-ID >:WS-STUDENT-ID
END-EXEC.

Abierto

Antes de usar un cursor, se debe realizar la instrucción Open. La instrucción Open prepara SELECT para su ejecución.

EXEC SQL
   OPEN STUDCUR
END-EXEC.

Cerca

La sentencia Close libera toda la memoria ocupada por el cursor. Es obligatorio cerrar un cursor antes de finalizar un programa.

EXEC SQL
   CLOSE STUDCUR
END-EXEC.

Ir a buscar

La instrucción Fetch identifica el cursor y coloca el valor en la cláusula INTO. Una instrucción Fetch se codifica en bucle a medida que obtenemos una fila a la vez.

EXEC SQL
   FETCH STUDCUR
   INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS
END-EXEC.

El siguiente ejemplo muestra el uso del cursor para recuperar todos los registros de la tabla ESTUDIANTE:

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.

DATA DIVISION.
   WORKING-STORAGE SECTION.
   
   EXEC SQL
   INCLUDE SQLCA
   END-EXEC.
   
   EXEC SQL
   INCLUDE STUDENT
   END-EXEC.
   
   EXEC SQL BEGIN DECLARE SECTION
   END-EXEC.
      01 WS-STUDENT-REC.
         05 WS-STUDENT-ID PIC 9(4).
         05 WS-STUDENT-NAME PIC X(25).
         05 WS-STUDENT-ADDRESS X(50).
   EXEC SQL END DECLARE SECTION
   END-EXEC.
   
   EXEC SQL
      DECLARE STUDCUR CURSOR FOR
      SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS FROM STUDENT
      WHERE STUDENT-ID >:WS-STUDENT-ID
   END-EXEC.

PROCEDURE DIVISION.
   MOVE 1001 TO WS-STUDENT-ID.
   PERFORM UNTIL SQLCODE = 100
   
   EXEC SQL
      FETCH STUDCUR
      INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS
   END-EXEC
   
   DISPLAY WS-STUDENT-REC
END-PERFORM	
STOP RUN.

JCL para ejecutar el programa COBOL anterior -

//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001  EXEC PGM=IKJEFT01
//STEPLIB  DD DSN=MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSIN  DD *
   DSN SYSTEM(SSID)
   RUN PROGRAM(HELLO) PLAN(PLANNAME) -
   END
/*

Cuando compila y ejecuta el programa anterior, produce el siguiente resultado:

1001 Mohtashim M.		Hyderabad
1002 Nishant Malik		Delhi
1003 Amitabh Bachan		Mumbai
1004 Chulbul Pandey		Lucknow