LOS SUBFICHEROS EN LA PRCTICA

Seccin: Diseo y Programacin - HELP400

==============================================================================
Introduccin a los subficheros
------------------------------------------------------------------------------

Las aplicaciones interactivas mejoran sensiblemente si en su diseo incorporamos

funciones de subfichero, por tanto, un correcto dominio de las tcnicas de
tratamiento de los subficheros puede incrementar significativamente la productividad
de nuestra instalacin.

Cmo codificar subficheros

Todos hemos tenido, de vez en cuando, necesidad de representar informacin en forma

tabular. Formatear los datos de salida en filas y columnas generalmente no
representa ninguna dificultad, es en la codificacin de las funciones de paginacin
en donde reside el problema. En este campo, el Sistema 38 aport, entre otras, una
importante novedad: el tratamiento de mltiples registros mediante el uso de
subficheros.
Bsicamente, el empleo de un subfichero permite manejar en pantalla mltiples
registros del mismo tipo y emplear las teclas de paginacin, bien sean controladas
desde el propio sistema operativo o bien, desde el programa que trata los datos.
Por ejemplo, un programa lee registros de un fichero de base de datos y los va
aadiendo mediante WRITE al subfichero de salida. Cuando se ha creado el subfichero
en su totalidad, el programa lo enva a pantalla mediante una sola operacin de
escritura. Despus de que el usuario haya revisado, modificado o aadido registros
al subfichero (dependiendo de la funcin a realizar), el programa lee todo el
subfichero desde el dispositivo de representacin, lo introduce en el programa y
procesa individualmente cada registro del subfichero.
Los subficheros gozan de gran popularidad en nuestro entorno porque, al usar
funciones directamente incluidas en el microcdigo, permiten aumentar nuestra
productividad y las prestaciones de nuestra aplicacin. De hecho, en la vida, nada
es gratuito y un uso errneo de los subficheros puede ser la causa de una importante
degradacin en el rendimiento del sistema. Cuando vayamos a disear subficheros
hemos de considerar estos posibles problemas de rendimiento. Uno de ellos se origina
en la manera en cmo se cargan y leen los datos del subfichero.
Hay tres formas distintas de tratar a un subfichero segn sea su naturaleza:
subficheros "completos", subficheros "pgina a pgina" y subficheros "de una
pgina" (les he asignado estos nombres con el fin de poderlos denominar de alguna
forma).

Subficheros "completos"

En algunos programas puede ser ventajoso el leer y cargar en el subfichero todos los
registros a visualizar, facilitando as, la paginacin total de los datos hacia
adelante o hacia atrs. Codificar este tipo de subficheros "completos" es simple:
leer un registro de la base de datos, escribirlo en el subfichero, repetir hasta que
se llegue al final del fichero de datos y entonces visualizar el subfichero. Esta
tcnica es la mejor cuando se procesan un nmero relativamente pequeo de registros
(un mximo de 50 o 60) que suelen corresponder a ficheros de tipo tablas. Emplear
programas con subficheros completos no es aconsejable cuando se usa un mayor nmero
de registros dado que la cantidad de tiempo necesaria para cargar el subfichero
puede significar un tiempo de espera excesivo antes de efectuar la visualizacin, y
por otra parte, el usuario quizs no necesite ver todos los registros para tomar una
accin determinada. Desgraciadamente, muchos programas que tratan cientos de
registros, estn escritos bajo esta tcnica, por ser la ms cmoda en el momento de
codificar. En este tipo de programas, la paginacin est totalmente soportada por el
propio sistema operativo.
Para emplear subficheros completos deberemos, en la definicin del SFLCTL de la DDS,
especificar el tamao del subfichero (palabra clave SFLSIZ, que seala el total de
registros del SFL) mayor que el tamao de la pgina de visualizacin (palabra clave
SFLPAG, que indica el nmero de lineas a visualizar por pgina). Cuando el SFLSIZ es
mayor que el SFLPAG, el subfichero automticamente se extiende cuando grabamos ms
registros de los indicados en el tamao. Para que esta funcin tenga lugar, como
mnimo deber ser SFLSIZ = SFLPAG + 1. Ya que el SFLSIZ indica el nmero de
registros que el SFL puede contener, tambin especifica la cantidad de espacio
reservada en el disco en el momento de la creacin del SFL. Si el subfichero se
extiende, un espacio adicional del disco se reserva de nuevo para poder admitir ms
registros. Este puede ser un problema de rendimiento adicional en caso de
paginacin, puesto que estas extensiones no estn juntas. Es mejor estimar un
valor determinado para el tamao del SFL, pero tampoco demasiado grande, un gran
tamao tambin implica disminucin del rendimiento.
La codificacin de la figura 1 demuestra el concepto de subfichero completo. Los
campos de su registro de subfichero y los campos del registro de control debern
incluirse en donde se indica. El indicador 61 se ha asignado al SFLCLR. Esto
significa que el indicador 61 deber ponerse en ON en el programa cuando el SFL
tenga que borrarse. El indicador 62 se ha asignado al SFLDSP y se pone en OFF cada
vez que se borra subfichero y solamente se pone en ON si se graba uno o ms
registros en el subfichero. Cuando el EXFMT del programa (figura 2) tiene lugar, si
el *IN62 est en ON (al menos hay un registro en el SFL), el subfichero se
visualiza. Esta tcnica evita el error que se produce cuando se intenta visualizar
un subfichero vaco.
El cdigo RPG para borrar, leer y visualizar el subfichero completo se muestra en la
figura 2. El programa lee el fichero de base de datos FICHERO para visualizarlo
mediante SFL. Se asume que el registro de control WSFLCTL incorpora un campo llamado
ARG en donde el usuario puede entrar el argumento de bsqueda. En la sentencia 016,
este argumento se usa para situar el fichero en el primer registro a recuperar. (IBM
denomina a esta funcin "posicionar el cursor del fichero"). Cuando el programa se
inicia, el registro de control se visualiza, solicitando al operador un argumento de
bsqueda. En este punto el SFL no se visualiza porque no hay registros y por tanto,
el *IN62 est apagado. Despus de entrar el ARG y haber pulsado INTRO, el subfichero
se borra y se carga. Una vez cargado el subfichero, el programa regresa a la
sentencia 011, mediante un bucle controlado por un DOUNTIL (hasta que *INKC sea 1 -
pulsado F3), para visualizar el registro de control; los registros del subfichero se
visualizarn si el *IN62 se ha puesto en ON durante el proceso.
El subfichero se borra en las sentencias 020-023, se carga en las sentencias 027-036
y se visualiza en la sentencia 011. En RPG, el proceso mediante nmero relativo de
registro se define como parte de la definicin SFILE, palabra clave situada en las
columnas 54-59 de una lnea de continuacin (independiente) de las especificaciones
de descripcin de ficheros para el fichero WORKSTN descrito externamente. La
definicin SFILE implica un fichero de actualizacin controlado en clculo con ADD
para el subfichero. El nmero relativo de registro (NRR) se incrementa en la
sentencia 033 y se restaura a ceros en la 021, cuando se borra el subfichero. Como
el SFLSIZ es 20 y mayor que el SFLPAG, si se han procesado ms de 20 registros, el
subfichero se extiende automticamente para que puedan aadirse todos los registros
al SFL. El programa finaliza cuando el operador pulsa F3 (en la sentencia 011,
sentencias anidadas 007-015-037-038 y la 042).

Subficheros "pgina a pgina"

Las ventajas de usar subficheros completos se basan en la comodidad de su

programacin y la paginacin automtica que facilita el OS. Los inconvenientes son,
con un volumen relativamente grande de datos, el largo tiempo de espera del operador
y el consumo de recursos del ordenador. Si el nmero de registros es pequeo, el
impacto en el sistema tambin es pequeo. No obstante, si la cantidad de registros
es grande, el consumo de recursos tambin lo es. Este problema se puede solucionar
usando subficheros tratados "pgina a pgina", representando una solucin mejor para
cuando se debe visualizar una gran cantidad de registros. La idea consiste en
minimizar el tiempo de espera del operador en la carga de registros y en el consumo
de recursos del ordenador. Con unos pocos cambios efectuados sobre el tratamiento de
los subficheros completos es posible tratar subficheros "pgina a pgina", dndole
al operador la impresin de que dispone de todo el fichero en todo momento.
Un programa de subfichero tratado pgina a pgina prepara la primera pgina del
subfichero y la visualiza al operador. Si se pulsa la tecla de Avance Pgina (Roll
Up), el control vuelve al programa y este adiciona una segunda pgina al SFL y lo
visualiza de nuevo. Si se pulsa Retroceder Pgina (Roll Down), el propio sistema
operativo se encargar de retroceder a la primera pgina. Si en estas circunstancias
se pulsa de nuevo Avance Pgina, el CPF paginar el subfichero a la segunda pgina.
Si se insiste en Avanzar, la tercera pgina deber aadirse y luego visualizarse.
El truco consiste en aadir la tecla Roll Up en la DDS del fichero de pantalla. Esto
hace que el CPF pagine el subfichero hacia adelante hasta que la ltima pgina
aadida se visualice de forma similar a la de los subficheros completos. Sin
embargo, si la ltima pagina se est visualizando y se pulsa de nuevo Avan Pg, el
control vuelve al programa como si se hubiera pulsado una tecla de funcin
cualquiera. El indicador asociado a la palabra clave ROLLUP se activa (ON) y el
programa puede probar esta situacin.
La codificacin para el subfichero pgina a pgina se muestra en las figuras 3 y 4.
Es una versin modificada del cdigo usado en el tratamiento de subficheros
completos. En la DDS se ha aadido la lnea 001 que activa la tecla Avan Pg y la
asigna al indicador 60. Tambin se ha aadido la lnea 009 con un campo oculto
(SFLRCD de cuatro Bytes numricos con signo) con la palabra clave SFLRCDNBR. El
campo se usa para posicionar el subfichero en la pgina adecuada durante la
operacin de visualizacin.
En el RPG se incorporan pocos cambios: slo las sentencias *016, *029, *038 y *042
diferencian un programa del otro. La lgica ha cambiado ligeramente para poder
saltarnos la rutina de borrado del SFL cuando la tecla Avan Pg ha sido pulsada.
Adems, la rutina de lectura/carga del subfichero no se repite hasta que se acaba el
fichero, sino que lee los prximos diez registros. Cuando se produce el EOF el
indicador 99 se pone en ON y como el END de la sentencia 038 est condicionado a
N99, el bucle finaliza cuando se alcanza el final de fichero. Si se produce EOF del
FICHERO, como la lnea 001 de la DDS est condicionada a N99, la palabra clave
ROLLUP queda sin efecto y, si el operador solicita avanzar de nuevo, le aparecer el
mensaje normal de fin de subfichero. Al mismo tiempo impide que el programa intente
leer ms registros de los existentes.
En la sentencia 042 el ltimo NRR usado se sita en el campo SFLRCD asociado al
SFLRCDNBR. Cuando se visualice el subfichero la palabra clave SFLRCDNBR har que se
visualice la pgina que contiene el numero relativo de registro cuyo valor numrico
se halla en le campo SFLRCD. Si no se hubiera aadido esta funcin, cada vez que se
visualizara el subfichero lo hara enseando siempre la primera pgina.
La mayor ventaja de esta tcnica se obtiene cuando el operador se da por satisfecho
con unas pocas pginas, si por el contrario pagina hacia adelante continuamente sin
encontrar lo que busca, el consumo de recursos se asemeja al de los subficheros
completos.

Subficheros "de una pgina"

El tercer tipo de tratamiento de subficheros es el mejor de todos y en algunos casos

requiere muy poca codificacin adicional (figuras 5 y 6), especialmente cuando la
funcin de Retro Pg no es fundamental y puede implementarse a travs de un
reposicionamiento del fichero de base de datos mediante el uso del campo ARG (en el
registro de control), en donde situaremos el nuevo argumento de bsqueda
correspondiente a una pgina anterior. Si ello no es posible o no es adecuado, la
mejor solucin consistir en tener este ARG dentro del propio subfichero, y una vez
activado el indicador asociado a la tecla de retroceso (en la DDS, palabra clave
ROLLDOWN), leer el primer registro del SFL para reposicionar el fichero de base de
datos y, desde all, retroceder mediante READP, tantos registros como sea el tamao
de pgina, estando as, posicionados al inicio de la pgina anterior.
La ventaja fundamental del uso de un subfichero "de una pgina" est en la poca
cantidad de recursos, tanto en memoria como en disco, que emplea y en que, cuando
SFLSIZ = SFLPAG puede emplearse "seleccin de campos", es decir, es la nica forma
en que podemos condicionar campos del SFL. Los principales inconvenientes vienen
determinados porque el sistema operativo no soporta las funciones de paginacin por
lo que deber ser el programa el que las controle mediante los indicadores asociados
al ROLLUP y ROLLDOWN.
Indudablemente, al planificar la pantalla hemos de tener en cuenta qu tipo de
subfichero emplearemos y, adems, cual ser el dilogo del programa con el usuario.
Si empleamos el campo ARG para un posicionamiento adecuado, tendremos que considerar
si ste estar al pi del subfichero o al inicio del mismo; si est al pi y en el
registro de control, la cabecera del subfichero deber ser otro formato de pantalla
y deberemos emplear OVERLAYs, etc. Como puede ver, cada mtodo tiene sus ventajas e
inconvenientes. El mtodo a emplear depender de las necesidades de su aplicacin y
de la forma en que el subfichero ser representado.
Hasta aqu slo hemos analizado los subficheros como un conjunto homogneo de
registros de salida a pantalla. En el prximo nmero, analizaremos el manejo y
codificacin de los subficheros con campos de entrada. Desde la forma ms simple, el
subfichero que incluye un campo de seleccin de registro para una funcin
determinada (normalmente usados en un subprograma de seleccin de datos), hasta el
ms complejo, para entrar o actualizar datos en forma "masiva" mediante el empleo de
un subfichero de entrada /salida.

==============================================================================
Eplogo a los subficheros
------------------------------------------------------------------------------

Los subficheros en la prctica

Las aplicaciones interactivas mejoran sensiblemente si en su diseo incorporan

funciones de subfichero, pero un uso inadecuado de los mismos puede ser la causa de
una importante degradacin en el rendimiento del sistema.

- Tipos de subficheros

Cuando codifique un subfichero de pantalla, el programador debe seleccionar el

mtodo apropiado para crear el subfichero, es decir, el mtodo de extraccin y
almacenamiento de los registros del archivo de base de datos que se van a procesar
mediante la tcnica de subficheros. El mtodo seleccionado depender de la
aplicacin y deber tener en cuenta el rendimiento de los programas en el ordenador.
En la primera parte de este artculo (HELP400 nmero 4) estudiamos con detalle la
codificacin de las DDS y RPG correspondientes a los tres mtodos de paginacin que
resumimos a continuacin.
Si el nmero de registros a presentar es relativamente pequeo (unos cien por
termino medio), lo ms simple es leerlos todos y visualizarlos de una sola vez (a
este mtodo lo denominamos "subficheros completos"); si por el contrario, el nmero
de registros a procesar es potencialmente grande, lo mejor ser leer los registros
necesarios para completar una pgina y, en caso de que el usuario desee ver ms
registros, al pulsar ROLLUP ceder el control al programa para que procese y aada
una nueva pgina de registros al subfichero (le denominamos "subficheros pgina a
pgina"); una tercera posibilidad consistir en presentar siempre una nueva pgina
de registros, el subfichero equivale a esta pgina (subficheros "de una pgina") y
el programa deber controlar tanto el retroceso como el avance de pginas. En el
cuadro adjunto al final del artculo, tenemos unos pequeos apuntes que pretenden
presentar, en un reducido resumen, lo ms esencial de los subficheros.

- Leyendo subficheros
Ahora que ya conocemos los diferentes tipos de subficheros y el impacto que pueden
causar en el rendimiento del ordenador, echemos una mirada a las diferentes maneras
de usarlos. Muchas veces el subfichero se emplea como visualizacin de una lista de
registros para que el usuario pueda hacer una seleccin de entre los mismos. Por
ejemplo, podemos escribir un programa con un subfichero para que visualice, por
nmero de pedido, las notas de envo pendientes de confirmar e imprimir. En las
lneas del subfichero podramos poner el nmero de nota, la fecha, el nmero de
cliente, la cantidad de lneas de la nota y el valor actual de la misma.
Adicionalmente, podramos situar un campo de entrada de una sola posicin, a la
izquierda de cada registro del subfichero, para que el usuario pudiera entrar un
cdigo de accin. El usuario podra poner una "C" en varios de los registros
visualizados para confirmar e imprimir varias notas a la vez. Para que el proceso
pueda continuar, el programa ha de ser capaz de leer los registros que han sido
modificados en el subfichero.
El mtodo usado para leer los registros modificados es francamente cmodo. En RPG,
el cdigo de operacin usado para leer registros modificados de un subfichero es el
READC. La operacin READC, empleada dentro de un bucle, efecta una lectura de cada
registro modificado y hace que los datos del registro modificado del subfichero
"entren de nuevo" en el programa. Un registro se considera modificado si algn dato
(incluido blancos) se entra desde el teclado en un campo del registro del subfichero
que sea susceptible de entrada. El hecho de modificar uno o varios campos en un
registro de pantalla altera el contenido de un campo interno del registro de
pantalla, llamado "Modified Data TAG" (MDT -un simple bit por cada uno de los campos
de la pantalla). El bit correspondiente se pone en ON si el campo ha sido modificado
por el usuario de la pantalla.
Si un MDT est en ON para un campo del subfichero, el registro se considera
modificado y por tanto, el READC lo procesar. Si un registro no ha sido modificado
por el usuario, no podr ser recuperado usando el cdigo de operacin READC.
Asumamos que el mtodo empleado para cargar y representar el subfichero en pantalla
es el que hemos denominado "pgina a pgina", la figura 7 nos muestra la
codificacin del programa en RPG, resaltando la rutina empleada para leer y procesar
los registros cambiados del subfichero. Si se recupera un registro, el campo de
entrada SEL se compara mediante un grupo CASE con "C" y si coincide, se ejecutar la
subrutina correspondiente. Si el usuario ha entrado cualquier otro cdigo (incluido
blancos) en el campo de seleccin, el registro se considerar modificado y tambin
ser recuperado por el READC, por eso debe probarse el campo SEL con los valores
predeterminados. Por supuesto, se puede extender el grupo CASE para que ejecute
otras subrutinas en funcin de otros cdigos predeterminados para el programa, en
nuestro ejemplo podramos incorporar una "R" para revisar alguna nota de las no
confirmadas y, eventualmente, modificarla o completarla.
El uso ms generalizado de esta tcnica suele ser el empleado en subprogramas de
seleccin. En el programa principal hay una serie de campos que pueden ser llenados
a partir de un subprograma con un subfichero de seleccin. La tcnica empleada para
llamar al subprograma puede variar segn la metodologa de la empresa, pero el
mecanismo siempre es el mismo. Supongamos que el usuario desconoce el valor a
introducir. En el campo de entrada puede teclear un "?" y pulsar INTRO (como en los
mandatos de nuestro sistema operativo), el programa principal llama entonces al
subprograma adecuado que interrumpir la pantalla (o bien abrir una ventana en la
misma), ofreciendo un subfichero de seleccin. La recuperacin mediante READC del
registro seleccionado, permitir devolver al programa principal el valor adecuado
empleando PARMS.
Por ejemplo (figura 8), supongamos que el campo a rellenar corresponde al cdigo de
los diferentes lugares de entrega para un cliente determinado; el "?" llamar al
subprograma pasando el cdigo de cliente empleando un primer PARM. El subprograma,
mediante SETLL y READE, montar un subfichero con todos los lugares de entrega del
cliente indicado (en este caso parece indicado emplear la tcnica de subfichero
"completo") y los mostrar en pantalla para que el usuario seleccione el adecuado.
Despus de ledo y procesado el registro cambiado, el cdigo del lugar de entrega se
pasa al programa principal mediante un segundo PARM.

- Usando el SFLNXTCHG

La correcta interpretacin de la funcin de esta palabra clave asociada a la DDS de

un subfichero, puede ser difcil si no se siguen detenidamente unos pocos ejemplos
que expliquen su uso ms habitual.
Tomemos de nuevo el ejemplo de las notas no confirmadas. Asumamos que lo que
pretendemos es que nuestro programa confirme e imprima automticamente todas las
notas que tengan menos de diez lneas, a excepcin de aquellas que explcitamente
nos seale el usuario, y que para ello, y slo como ejemplo explicativo del uso del
SFLNXTCHG, vamos a emplear una tcnica parecida a la del programa de la figura 7.
La primera cosa que necesitaramos hacer es que el programa pusiera una "C" en el
campo de seleccin SEL (definido como de entrada/salida) en el momento en que cada
uno de los registros fuera grabado en el subfichero. Esto cumplira el requisito de
una "C" para la rutina de confirmacin. Puesto que el usuario no modifica los
registros del subfichero, la operacin READC no recuperar ni procesar los
registros marcados con una "C". La solucin para recuperar estos registros consiste
en emplear la palabra clave SFLNXTCHG en el registro de control de la DDS, que, si
est activada cuando grabamos el registro en el subfichero, har que este registro
se comporte (en la prxima lectura) como si hubiera sido modificado por el usuario.
La palabra clave SFLNXTCHG puede ser activada para cada registro (individualmente)
en el momento en que ste se graba en el subfichero. As el READC recuperar el
registro y la nota se confirmar e imprimir automticamente. Si el usuario decide
no confirmar una o varias notas determinadas, puede blanquear el cdigo "C". El
READC recuperar tambin estos registros "blanqueados", pero como el campo SEL est
en blanco, no actuar la rutina de confirmacin.
Supongamos que la aplicacin requiere que el campo de total lneas parpadee cuando
la nota de entrega sea inferior a diez lneas. Esta es una tarea simple porque los
atributos de campo pueden emplearse tambin con los registros del subfichero. La
funcin de parpadeo se activa usando en la DDS la palabra clave DSPATR(BL). En la
DDS de la figura 9 el campo TOTLIN tiene DSPATR(BL) condicionado por el indicador
41. El indicador 41 se pone en ON si el total de lneas es menor que 10, haciendo
que el campo parpadee al grabarse en el subfichero con este indicador activado. El
registro de control del subfichero debe tener la palabra clave SFLNXTCHG
condicionada por un indicador, en nuestro ejemplo est condicionada por el indicador
40. El cdigo RPG de la figura 10 complementa nuestra DDS y vemos que, para cada
registro que se lee del archivo de base de datos, se compara el total de lneas, si
el total de lneas es inferior a 10, se activan los indicadores 40 y 41 y se mueve
una "C" al campo SEL. Si son 10 o ms las lneas de la nota, es necesario
restablecer los indicadores y dejar en blanco el campo SEL antes de grabar el
registro en el subfichero.

- El SFLNXTCHG en la depuracin de errores

La palabra SFLNXTCHG tambin puede usarse para efectuar la depuracin de errores en

los campos de entrada de los registros del subfichero. Si no empleamos el SFLNXTCHG,
los errores pueden entrar en nuestro sistema de una forma totalmente incontrolada.
Veamos un ejemplo en donde el usuario actualiza, mediante el uso de un subfichero,
el cdigo de situacin de un cliente determinado. Cuando pulsa INTRO, el programa
ejecuta un bucle con READC para obtener los registros modificados. En este momento
se comprueba la validez del cdigo de situacin para este tipo de cliente (se
entiende que no puede validarse desde la DDS con VALUE, RANGE, etc.). Si no es
vlido, el programa pone en ON un indicador para el mensaje de error y cuando todos
los registros han sido procesados, si el indicador de error est activado, se
visualizar de nuevo el subfichero. En este momento el usuario puede, en lugar de
repasar y cambiar los registros errneos, pulsar simplemente INTRO de nuevo y, como
los registros no han sido modificados, el bucle READC no los procesar, por tanto,
la tcnica empleada en el prrafo anterior es inadecuada.
La solucin correcta para el tratamiento de errores (figura 11) consistir en
activar, adems del indicador general de errores, un indicador individual que
condicione un DSPATR(RI) para cada campo errneo y un indicador nico para
condicionar un SFLNXTCHG, y a continuacin, actualizar en el subfichero el registro
que se est procesando con estos indicadores activados. El contenido de los campos
no tiene por qu variar (al menos que se desee hacerlo expresamente) pero los MDTs
del registro actualizado con SFLNXTCHG estarn activos, haciendo que en la prxima
lectura, una vez dado el INTRO, se lea de nuevo este registro como si hubiera sido
variado por el usuario, independientemente de que el usuario corrija o no los
errores.

- Otras consideraciones

Desde el momento en que sabemos controlar los posibles errores de una entrada de
datos efectuada a travs de un subfichero, podemos concebir programas cuya funcin
principal sea la entrada y/o modificacin de registros en un determinado archivo de
base de datos. Normalmente esta posibilidad inquieta a ms de un programador
experimentado que preferir emplear un registro de entrada/actualizacin al pie de
la pantalla y un subfichero que vaya representando los registros tratados. No es que
esta tcnica no sea vlida, al contrario, en muchos casos suele ser la mejor
solucin, pero nunca debemos descartar otras posibilidades por miedo a posibles
complicaciones que por otra parte, slo se presentarn en caso de tener poca
prctica.
Si la cantidad de registros a procesar es reducida y el riesgo de prdida de datos,
mnimo, el mejor sistema ser emplear un subfichero. Para ello usaremos un
subfichero "completo" que, si lo usamos para una entrada pura, deberemos inicializar
mediante el SFLINZ. El usuario ir aadiendo todos los datos de cada uno de los
registros y cuando pulse INTRO, estos se depurarn y procesarn adecuadamente
mediante un bucle de READC. Esta tcnica puede emplearse perfectamente en un
programa de entrada de pedidos en donde sabemos que la cantidad de lneas no ser
excesiva.
Un poco ms complejo resultar el programa de modificacin de ms de un registro a
la vez y que use un subfichero para ello. Mi tcnica favorita consiste en
inicializar primero el subfichero y luego cargarle, mediante CHAIN por NRR y UPDAT,
los registros ledos de la base de datos. La forma en que luego los registros del
subfichero "vuelven" al archivo de base de datos, depender principalmente de si han
habido supresiones y/o adiciones de nuevas lneas, si en el subfichero se han
aadido ms, estos debern adicionarse al archivo y si hay menos, los que sobran de
la base de datos debern suprimirse.
El mtodo usado depende de los requisitos del programa de la aplicacin que se est
desarrollando y de la forma en que los datos del subfichero sern representados. El
dominio de los subficheros puede representar un empujn significativo en la
productividad de programacin, y si se codifican y usan adecuadamente, la incidencia
en el rendimiento del ordenador ser mnima.

--- CUADRO RESUMEN

SUBFICHEROS

Permiten manejar en pantalla mltiples registros del mismo tipo mediante teclas ROLL
controladas desde el CPF o desde el PGM.

- DOS FORMATOS EN LA DDS:

SFL: Contiene los campos a aparecer bajo el control del CTL

SFLCTL: Hace que tengan lugar las operaciones fsicas (preparacin, representacin,
lectura), puede adems, contener campos propios.
- MINIMO DE PALABRAS CLAVE ASOCIADAS (EN EL SFLCTL):

SFL ........... define los campos del SUBFILE

SFLCTL......... define el CONTROL del subfile
SFLSIZ......... tamao subfile en disco
SFLPAG......... tamao pgina en pantalla
SFLDSPCTL ..... visualizar SFLCTL y sus campos
SFLDSP ........ visualizar los registros del SFL
SFLCLR ........ limpiar SFL

- OTRAS PALABRAS CLAVE FRECUENTES:

SFLEND (+) registros en SFL SFLINZ para inicializar todo el SFL

SFLLIN indicar espacio entre columnas SFLDLT para que pgm lo suprima
SFLDROP doblar o truncar registros SFLRCDNBR pgina a visualizar s/NRR

- TRES TECNICAS DIFERENTES DE ALMACENAMIENTO:

SFLSIZ= SFLPAG ... Mximo prestaciones, control completo por pgm

SFLSIZ= SFLPAG + 1 Prestaciones normales, control CPF y pgm
SFLSIZ= SFLPAG * x Prestaciones s/num. registros, control TOTAL por CPF.

- FORMA SIMPLE: Control ROLLs por CPF (Slo para SFLs pequeos < 100 reg.) Las
prestaciones disminuyen si la carga inicial es grande o el espacio no es contiguo.

- FORMA MIXTA: Control ROLLUP por pgm y ROLLDOWN por CPF. En ambos casos se define
el SFLSIZ mayor que el SFLPAG. El CPF extiende el espacio del SFL automticamente
pero decrece el rendimiento.

- FORMA COMPLEJA: Control de la paginacin por programa. (SFLSIZ = SFLPAG) hay

funciones (condicionado de campos del SFL, etc.) slo validas en esta modalidad.

- OPERACIONES BASICAS a realizar por el PGM:

* Leer registros de un fichero, WRITE de uno en uno en el SFL

* Enviar el SFL a pantalla mediante operacin salida del SFLCTL
* Leer el SFLCTL despus de que el usuario haya revisado, modificado o
aadido registros (dependiendo de la funcin del SFL)
* Procesar cada registro del SFL individualmente.

- SUBFICHEROS EN RPG

El SFILE implica proceso mediante NRR de un fichero de actualizacin controlado en

clculo con ADD. Las operaciones vlidas para el registro del subfichero son: CHAIN,
UPDAT, WRITE y READC. Las operaciones en pantalla van controladas a travs del
SFLCTL.

Alberto C. Blanch

==============================================================================
HELPNET -> Un servicio informativo para los suscriptores de la revista HELP400
==============================================================================
Archivo: figura_01.dsp

SUBFIC_A DSPF Pantala de subfichero

A* Figura 1
A*
A R WSFL SFL
A*
A* INSERTE LOS CAMPOS DE SU SUBFICHERO AQUI
A*
A R WSFLCTL SFLCTL(WSFL)
A SFLSIZ(0020)
A SFLPAG(0010)
A CA03(03 'Salir')
A N61 62 SFLDSP
A N61 SFLDSPCTL
A 61 SFLCLR
A*
A* INSERTE LOS CAMPOS DE SU REG. DE CONTROL AQUI
A*

Pgina: 1
Archivo: figura_02.rpg

SUBFIC_A RPG Ejemplo de programa de tratamiento de subficheros

F*/FILE
F* Figura 2
FWRKSTN CF E WORKSTN
F NRR KSFILE WSFL
FFICHERO IF E K DISK
C*/CALC
C*
C*-- EJECUTAR HASTA QUE SE PULSE F3
C*-- ----------------------------------
C*--HASTA CA03
C *INKC DOUEQ*ON
C*
C*-- REPRESENTAR PANTALLA
C*-- --------------------
C*--- DISPLAY
C EXFMTWSFLCTL
C*
C*-- POSICIONARSE EN EL FICHERO CON ARGUMENTO BUSQUEDA (SI NO F3)
C*-- ----------------------------------------------------------------
C*--- NO CA03
C *INKC IFEQ *OFF
C*--- 1ER REG
C ARG SETLLFICHERO
C*
C*-- CLEAR SUBFILE
C*-- -------------
C*--- IN 61-62
C MOVE *ON *IN,61
C MOVE *OFF *IN,62
C*--- INIT
C Z-ADD*ZEROS NRR 50
C*--- SFLCLR
C WRITEWSFLCTL
C*--- IN 61-62
C MOVE *OFF *IN,61
C MOVE *OFF *IN,62
C*
C*-- LEER FICHERO DATOS
C*-- ------------------
C*--- HASTA EOF
C *IN99 DOUEQ*ON
C*--- READ
C READ FICHERO 99
C*
C*-- WRITE REGISTRO AL SUBFILE SI NO FIN-DE-FICHERO (EOF)
C*-- ----------------------------------------------------
C*--- NO EOF
C *IN99 IFEQ *OFF
C*--- IND.POSIT
C ADD 1 NRR 50 62
C*--- WRITE
C WRITEWSFL
C ENDIF
C ENDDO
C ENDIF
C ENDDO
C*
C*-- TERMINAR PROGRAMA
C*
C*--- TERMINAR

Pgina: 1
Archivo: figura_02.rpg

C MOVE *ON *INLR

Pgina: 2
Archivo: figura_03.dsp

SUBFIC_B DSPF Pantala de subfichero

* Figura 3
*
A N99 ROLLUP(60)
A R WSFL SFL
*
* INSERTE LOS CAMPOS DE SU SUBFICHERO AQUI
*
A R WSFLCTL SFLCTL(WSFL)
A SFLSIZ(0011)
A SFLPAG(0010)
A CA03(03 'SALIR')
A N61 62 SFLDSP
A N61 SFLDSPCTL
A 61 SFLCLR
A SFLRCD 4S 0H SFLRCDNBR
* INSERTE LOS CAMPOS DE SU REG. DE CONTROL AQUI

Pgina: 1
Archivo: figura_04.rpg

SUBFIC_B RPG Programa de subficheros

F*/FILE
F* Figura 4
FWRKSTN CF E WORKSTN
F NRR KSFILE WSFL
FFICHERO IF E K DISK
C*/CALC
C*
C*-- EJECUTAR HASTA QUE SE PULSE MDTO-3
C*-- ----------------------------------
C*--HASTA CA03
C *INKC DOUEQ'1'
C*
C*-- REPRESENTAR PANTALLA
C*-- --------------------
C*--- DISPLAY
C EXFMTWSFLCTL
C*
C*-- POSICIONARSE EN EL FICHERO CON ARGUMENTO BUSQUEDA (SI NO MDTO-3)
C*-- ----------------------------------------------------------------
C*--- NO CA03
C *INKC IFEQ '0'
C*--- NO ROLL
C *IN60 IFEQ '0'
C*--- 1ER REG
C ARG SETLLFICHERO
C*
C*-- CLEAR SUBFILE
C*-- -------------
C*--- IN 61-62
C MOVEA'10' *IN,61
C*--- INIT
C Z-ADD0 NRR 50
C*--- SFLCLR
C WRITEWSFLCTL
C*--- IN 61-62
C MOVEA'00' *IN,61
C ENDIF
C*
C*-- LEER FICHERO DATOS
C*-- ------------------
C*--- 10 REGS.
C DO 10
C*--- READ / EOF
C READ FICHERO 99
C*
C*-- WRITE REGISTRO AL SUBFILE SI NO FIN-DE-FICHERO (EOF)
C*-- ----------------------------------------------------
C*--- NO EOF
C *IN99 IFEQ '0'
C*--- IND.POSIT
C ADD 1 NRR 62
C*--- WRITE
C WRITEWSFL
C ENDIF
C N99 ENDDO
C*
C*-- INICIALIZAR EL SFLRCDNBR PARA POSICIONAR PAGINA
C*-- -----------------------------------------------
C*--- INICIAR
C Z-ADDNRR SFLRCD

Pgina: 1
Archivo: figura_04.rpg

C ENDIF
C ENDDO
C*-- TERMINAR PROGRAMA
C*--- TERMINAR
C MOVE '1' *INLR

Pgina: 2
Archivo: figura_05.dsp

SUBFIC_C DSPF Pantala de subfichero

* Figura 5
*
A ROLLUP(60)
A R WSFL SFL
*
* INSERTE LOS CAMPOS DE SU SUBFICHERO AQUI
*
A R WSFLCTL SFLCTL(WSFL)
A SFLSIZ(0010)
A SFLPAG(0010)
A CA03(03 'SALIR')
A N61 62 SFLDSP
A N61 SFLDSPCTL
A 61 SFLCLR
*
* INSERTE LOS CAMPOS DE SU REG. DE CONTROL AQUI

Pgina: 1
Archivo: figura_06.rpg

SUBFIC_D RPG Programa de subfichero

F*/FILE
F* Figura 6 FWRKSTN CF E WORKSTN
F NRR KSFILE WSFL
FFICHERO IF E K DISK
C*/CALC
C*
C*-- EJECUTAR HASTA QUE SE PULSE MDTO-3
C*-- ----------------------------------
C*--HASTA CA03
C *INKC DOUEQ'1'
C*
C*-- REPRESENTAR PANTALLA
C*-- --------------------
C*--- DISPLAY
C EXFMTWSFLCTL
C*
C*-- POSICIONARSE EN EL FICHERO CON ARGUMENTO BUSQUEDA (SI NO MDTO-3)
C*-- ----------------------------------------------------------------
C*--- NO CA03
C *INKC IFEQ '0'
C*--- NO ROLL
C *IN60 IFEQ '0'
C*--- 1ER REG
C ARG SETLLFICHERO
C ENDIF
C*
C*-- CLEAR SUBFILE
C*-- -------------
C*--- IN 61-62
C MOVEA'10' *IN,61
C*--- INIT
C Z-ADD0 NRR 50
C*--- SFLCLR
C WRITEWSFLCTL
C*--- IN 61-62
C MOVEA'00' *IN,61
C*
C*-- LEER FICHERO DATOS
C*-- ------------------
C*--- 10 REGS.
C DO 10
C*--- READ / EOF
C READ FICHERO 99
C*
C*-- WRITE REGISTRO AL SUBFILE SI NO FIN-DE-FICHERO (EOF)
C*-- ----------------------------------------------------
C*--- NO EOF
C *IN99 IFEQ '0'
C*--- IND.POSIT
C ADD 1 NRR 62
C*--- WRITE
C WRITEWSFL
C ENDIF
C N99 ENDDO
C*
C ENDIF
C ENDDO
C*-- TERMINAR PROGRAMA
C*--- TERMINAR
C MOVE '1' *INLR

Pgina: 1
Archivo: figura_07.rpg

SUBFIC_E RPG Programa de subfichero

F*/FILE
F* Figura 1: Ejemplo empleo READC
F*
FWRKSTN CF E WORKSTN
F NRR KSFILE WSFL
FARCHIVO IF E K DISK
FLIST O F 180 OF PRINTER
C*/CALC
C*--- Inicio
C*--INICIALIZA
C MOVE *LOVAL ARG
C*
C*--HASTA CA03
C *INKC DOUEQ'1'
C*--- DISPLAY
C EXFMTWSFLCTL
C*
C*--- Procesar
C*
C*--- NO CA03
C *INKC IFEQ '0'
C*--- NO ROLL
C *IN60 IFEQ '0'
C*
C*--- Leer posibles cambiados
C*
C*-- <--
C NRR IFNE 0
C*--- UNTIL EOF .
C *IN92 DOUEQ'1'
C*--- LEER CAMBIO .
C READCWSFL 92
C*--- HAY CAMBIOS .
C *IN92 IFEQ '0'
C*--->CONFIRMAR .
C SEL CASEQ'C' SRCONF
C*-- .
C ENDCS
C*-- .
C ENDIF
C*-- .
C ENDDO
C*-- <--
C ENDIF
C*
C*--- Posiciona y Nuevo Sfl
C*
C ARG SETLLARCHIVO
C*--- IN 61-62
C MOVEA'10' *IN,61
C*--- INIT
C Z-ADD0 NRR 30
C*--- SFLCLR
C WRITEWSFLCTL
C*--- IN 61-62
C MOVEA'00' *IN,61
C ENDIF
C*--- Leer/Cargar
C DO 10
C*--- READ

Pgina: 1
Archivo: figura_07.rpg

C READ ARCHIVO 99
C*--- NO EOF
C *IN99 IFEQ '0'
C*--- HAY REGS
C ADD 1 NRR 62
C*--- WRITE SFL
C WRITEWSFL
C ENDIF
C*--->ENDDO
C N99 ENDDO
C*--- Situar
C*--- SFLRCDNBR
C Z-ADDNRR SFLRCD
C*--- INKC = 0
C ENDIF
C ENDDO
C*
C*--- Terminar PGM
C*
C*--- TERMINAR
C MOVE '1' *INLR
C RETRN
C*-------------------------------------------------------------------*
C*-- SRCONF: CONFIRMAR NOTAS / ACTUALIZAR ARCHIVO *
C*-------------------------------------------------------------------*
C SRCONF BEGSR
C*--...

Pgina: 2
Archivo: figura_08.rpg

SUBFIC_G RPG Programa de subfichero

* Subprograma de seleccion
*
F*/FILE
FWRKSTN CF E WORKSTN
F NRR KSFILE WSFL
FLUGARES IF E K DISK
C*/CALC
C*-- Parametros de enlace
C*
C *ENTRY PLIST
C PARM PCODCL
C PARM PLUGAR 2
C*-- Clave
C KEY KLIST
C KFLD PCODCL
C*-- Borrar Sfl
C*--- IN 61-62
C MOVEA'10' *IN,61
C*--- INIT
C Z-ADD0 NRR 50
C*--- SFLCLR
C WRITEWSFLCTL
C*--- IN 61-62
C MOVEA'00' *IN,61
C*
C*-- Posicionar
C*
C MOVE *BLANK SEL
C KEY SETLLLUGARES
C*
C*-- Leer y cargar hasta fin-de-grupo
C*
C*--- HASTA EOG
C *IN99 DOUEQ'1'
C*--- READ
C KEY READELUGARES 99
C*--- NO EOF
C *IN99 IFEQ '0'
C*--- 62=DISPLAY
C ADD 1 NRR 62
C*--- WRITE
C WRITEWSFL
C ENDIF
C ENDDO
C*
C*-- Representar y leer posible marcado
C*
C EXFMTWSFLCTL
C*-- Leer marcado
C*-- EOF
C READCWSFL 65
C *IN,65 IFEQ *OFF
C MOVE LUGAR PLUGAR
C ENDIF
C*-- Fin programa
C SETON LR
C LR RETRN

Pgina: 1
Archivo: figura_08a.rpg

SUBFIC_F RPG Programa de subfichero

* Figura 2: Ejemplo subprograma de seleccin
* Programa Principal
C*/CALC
C*
C WLUGAR IFEQ '? '
C CALL 'SUBPGM'
C PARM CODCLI PCODCL
C PARM PLUGAR
C PLUGAR IFNE *BLANKS
C MOVE PLUGAR WLUGAR
C ENDIF
C ENDIF

Pgina: 1
Archivo: figura_09.dsp

SUBFIC_G DSPF Pantala de subfichero

* Figura 3: Ejemplo de la DDS
*
A R WSFL SFL
A TOTLIN
A 41 DSPATR(BL)
* Inserte otros campos aqui
*
A R WSFLCTL SFLCTL(WSFL)
A SFLSIZ(0011)
A SFLPAG(0010)
A CA03(03 'SALIR')
A N61 62 SFLDSP
A N61 SFLDSPCTL
A 61 SFLCLR
A 40 SFLNXTCHG
* Campos del Reg. de control

Pgina: 1
Archivo: figura_10.rpg

SUBFIC_I RPG Programa de subfichero

C*/CALC
C*-- Figura 4.: Codificacin en RPG
C*
C*--- HASTA EOF
C *IN99 DOUEQ'1'
C*--- EOF
C READ ARCHIVO 99
C*--- HAY
C *IN99 IFEQ '0'
C*
C*--- < 10
C TOTLIN IFLT 10
C*--- MARCAR
C MOVE 'C' SEL
C*--- SFLNXTCHG
C MOVE '1' *IN40
C*--- DSPATR(BL)
C MOVE '1' *IN41
C*--- INCREMENTA
C ADD 1 NRR
C WRITEWSFL
C*--- RESTAURA
C MOVE ' ' SEL
C*--- "
C MOVE '0' *IN40
C*--- "
C MOVE '0' *IN41
C ENDIF
C ENDIF
C ENDDO
C*

Pgina: 1
Archivo: figura_11.rpg

SUBFIC_C RPG Programa de subfichero

* Figura 5: Depuracin de errores
*
C*/CALC
C*--- DEPURACION
C VERIF BEGSR
C SETOF 72
C *IN72 DOWEQ'0'
C READCWSFL 72
C *IN72 IFEQ '0'
C MOVEA*ZEROS *IN,91
C*
C*--- ERROR
C CODSIT COMP 'A' 9191
C*--- ERROR
C CANT COMP *ZEROS 92
C*
C 91
C*--55=SFLMSG
COR 92 SETON 4055
C UPDATWSFL
C*--40=SFLNXTCHG
C SETOF 40
C*--<- IN72=0
C ENDIF
C*--<- DOW
C ENDDO
C ENDSR
C*--------------------------------------------------------------------*

Pgina: 1