00 Informix 4gl Espanol2 PDF

VS
Por :
Ing. Juan Carlos Contreras Villegas
(c) Derechos Reservados

prohibida su reproduccin total o parcial
sin el consentimiento del autor
. Curso de Programacin en INFORMIX-4GL
CONTENIDO
I INTRODUCCION
1. Que es el INFORMIX?
2. Que es una base de datos?
3. Que es una tabla?
4. Base de datos ejemplo.
III PROGRAMACION EN INFORMIX-4GL

1. Estructura de un Programa 4GL
2. Tipos de datos en INFORMIX 4GL
3. Declaracin de variables
4. Asignacin de datos
5. Estructuras de control
5.1 Estructura Secuencial
5.2 Estructura Alternativa
5.3 Estructura Repetitiva
6. Manejo de Menes
7. Formatos de pantalla
7.1 Estructura de un formato de pantalla
7.2 Instrucciones para manejo de formatos de pantalla desde 4GL
6. Captura de datos
7. Query By Example
9.1 Especificacin del criterio de bsqueda
9.2 Preparacin de la consulta
9.3 Manejo de cursores
10. Reportes simples
10.1 Construccin del reporte
10.2 Estructura del Formato de reporte
10.3 Sentencias que se utilizan en la funcin reporte
10.4 Variables y funciones que se pueden usar en un formato de reporte
11. Manejo de arreglos con formatos de pantalla
11.1 Captura de datos en arreglos
11.2 Instrucciones para manejo de arreglos con formatos de pantalla
12. Reportes complejos con cortes de control
Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

Pgina 1
I
INTRODUCCIN
1.1.- Introduccin.-
4GL .- Four Generation Language (Lenguaje de programacin de cuarta

generacin), es un lenguaje de programacin que conjuntamente con el SQL
permiten crear sistemas de archivos.
INFORMIX-4GL es un lenguaje de cuarta generacin muy poderoso que provee

todas las herramientas que tu necesitas para crear sistemas de manejo de base de
datos relacionales
INFORMIX-4GL consta de:

SQL (Para la manipulacin de los datos)
Estructuras de control (IF, WHILE, Etc)
Manejo de mens
Manejo de ventanas
Formatos de pantalla
Reportes
2.- Que es una Base de datos ?

- Es una coleccin de informacin o datos relacionados.
- Es un conjunto de archivos relacionados.
- Es una coleccin de tablas.
3.- Que es una tabla ?

Una tabla es una coleccin de datos organizados en filas y columnas
Una base de datos contiene al menos una tabla, como tambin puede tener
muchas tablas, tantas como sea necesario.
4.- Para poder llevar adelante el curso se hace necesario trabajar sobre un ejemplo, para
as poder ser mas objetivo, y hacer que se comprenda mejor el manejo de INFORMIX
con un ejemplo practico.

Pgina 2
El ejemplo planteado para el presente curso es un sistema de control de almacn

para la empresa DELTA. El diseo de la base de datos ALMACEN es la siguiente:
Base de datos ALMACEN
cod_sec descrip fecha nro_egr
1 N
SECCION Recibe EGRESO
M
cod_pro nombre
p_unit
direc cant
PROVEEDOR
Contiene
1
fecha
p_unit
Hace cod_mat
nro_ing descrip cantidad
p_unit cant stock_min
N N
M
INGRESO Tiene MATERIAL
N

Pgina 3
Descripcin de las tablas para la base de datos ALMACEN
PROVEEDOR
cod_prov nombre direc
MATERIAL
cod_mat descrip p_unit stock_min cantidad
SECCION
cod_sec descrip
INGRESOS
nro_ing fecha cod_prov
EGRESOS
nro_egr fecha cod_sec
MAT_ING
nro_ing cod_mat cant p_unit
MAT_EGR
nro_egr cod_mat cant p_unit

Pgina 4
III
INFORMIX - 4GL
SQL + Estructuras de control + Formatos de pantalla + Reportes = 4GL
3.1.-- ESTRUCTURA DE UN PROGRAMA 4GL.-

DATABASE NombreBaseDeDatos
GLOBALS
aqui va la declaracion de variables globales
END GLOBALS
MAIN
Sentencias
------
------
------
END MAIN
FUNCTION NombreFuncion(lista de argumentos)

definicion de argumentos
definicion de variables locales
Sentencias
----
----
----
END FUNCTION
REPORT NombreFuncionReporte(lista de argumentos)

definicion de los argumentos
definicion de variables locales al reporte
Sentencias de reporte
-----
-----
-----
END REPORT

Pgina 5
En un programa 4GL existen 5 secciones, las cuales se detallan a continuacin:
Seccin DATABASE.- En esta seccin se especifica el nombre de la base de datos con la

que se va a trabajar.
Seccin GLOBALS.- En esta seccin se definen las variables que sern globales a todo
el programa.
Seccin MAIN .- En esta seccin se escriben la instrucciones.
Seccin FUNCTION.- Se pueden definir las funciones o procedimientos que seran

necesarios para el programa.
Seccin REPORT.- Tambin se pueden definir funciones especiales que dan formato a
los reportes.
Nota:
Toda Sentencia en INFORMIX-4GL siempre comienza con una palabra
reservada, la sentencia puede estar escrita en mas de una lnea. Una sentencia 4GL
termina cuando comienza otra sentencia.
El sistema a desarrollar se llamara SCA (Sistema de control de almacn) y estar

compuesto por los siguientes mdulos
sca_main
sca_mate sca_prove sca_secc sca_ingr sca_egre sca_repo
modulos
programa
Un programa en 4GL esta compuesto por mdulos, de los cuales solo uno de ellos
debe tener la palabra reservada MAIN y sera considerado mdulo principal.

Pgina 6
El diseo de pantalla para el sistema ser el siguiente:
Linea de Menu Menu: Materiales Proveedores seCcion Ingresos Egresos Reportes Salir
Linea de ABC de materiales
Comentarios ---------------------------------------------------------------------------------------------------
S I S T E M A
Formatos
de D E C O N T R O L
pantalla
D E A L M A C E N
---------------------------------------------------------------------------------------------------
Linea de Mens.
Linea de Mens.
de error
3.2.- TIPOS DE DATOS.-
3.2.1.-Tipos de dato simples-

CHAR(n) .- string de n caracteres
SMALLINT.- un numero en el rango de -32767 a 34767
INTEGER.- Un numero en el rango de -2.147.483.647 a 2.147.483.647
DECIMAL(m,n).- Un numero decimal en punto flotante, con un total de 32 (m)
dgitos significativos, y n (n<=m) dgitos a la derecha de la coma decimal.
Cuando se le da ambos parmetros (m y n) la variable tiene aritmtica de punto
fijo.
MONEY(m,n).- Su comportamiento es similar al tipo de dato DECIMAL. si no
tiene ningn parmetro es interpretado como un DECIMAL(16,2), si solo tiene el
parmetro m es interpretado como DECIMAL(m,2).
DATE.- Es una fecha ingresado como string de caracteres.
DATETIME first TO last.- almacena un momento en el tiempo con la precisin
first a last. Una columna DATETIME consiste de una secuencia de campos YEAR,
MONTH, DAY, HOUR, MINUTE, SECOND y FRACTION(n) de segundo.
INTERVAL first TO last.- Almacena un espacio de tiempo con la precisin first a
last. Una columna INTERVAL consiste de una secuencia contigua de uno de las
dos siguientes listas de campos:YEAR y MONTH o DAY, HOUR, MINUTE,
SECOND y FRACTION(n) de segundo.

Pgina 7
3.2.2.-Tipos de dato compuestos.-

En 4GL se pueden definir variables registros, pero no se pueden definir tipos de datos.
NomVariable RECORD
NomCampo1 Tipo1,
NomCampo2 Tipo2,
--------
--------
NomCampoN TipoN
END RECORD
3.2.3.- Arreglos-
En 4GL se pueden definir variables arreglos de n dimensiones simples o arreglos de
registros, pero no se pueden definir tipos de datos.
NombreVariable ARRAY [ m, n,.. ] OF TipoDato
3.3.-DECLARACION DE VARIABLES.-
La palabra reservada DEFINE permite declarar variables.
DEFINE Var1 TipoDato,
Var2 Tipo2,
---
---
VarN TipoN
Ejemplos:
DEFINE a SMALLINT,
b,c DECIMAL(10,2),
d RECORD
x SMALLINT,
y INTEGER
END RECORD,
e LIKE proveedor.cod_prov,
f RECORD LIKE proveedor.*,
g ARRAY [10] OF INTEGER,
h ARRAY [10,3] OF DATE,
i ARRAY [15] OF RECORD
x DATE,
y MONEY(5)
END RECORD,
j ARRAY [10] OF RECORD LIKE material.*

Pgina 8
3.4.-ASIGNACION DE DATOS-
Sintaxis:
LET NombreVariable = Expresion
INITIALIZE var1,var2,... TO NULL
La sentencia LET permite asignar el valor de una expresion a una variable.

La sentencia INITIALIZE permite inicializar una o mas variables a NULL. NULL en
4GL significa ausencia de dato, no cero (0), ni cadena vacia ("").
Ejemplos:
LET a=5
LET b=10.3*5
INITIALIZE d.x,d.y TO NULL
INITIALIZE d.* TO NULL
3.5.-ESTRUCTURAS DE CONTROL.-
3.5.1.- Secuencial.-
Como se menciono anteriormente una sentencia en INFORMIX-4GL comienza con
una palabra reservada, y puede ocupar mas de una lnea en el editor, y termina
cuando comienza otra sentencia.
Ejemplo
1 INITIALIZE x,
y TO NULL
2 SELECT * FROM material
WHERE cod_mat > 200
ORDER BY descrip
En este ejemplo se han escrito 2 sentencias, la sentencia 1 (INITIALIZE )ocupa dos

lineas, y la sentencia 2 (SELECT) ocupa tres lineas.
3.5.2.-Alternativa.-
3.5.2.1.- Alternativa simple.-

IF Condicion THEN
Sentencia
-----
END IF

Pgina 9
3.5.2.2.-Alternativa doble.-
IF Condicion THEN
Sentencia
-----
ELSE
Sentencia
----
END IF
3.5.2.3.-Alternativa multiple.-
CASE
WHEN expresion1
Sentencia
----
----
WHEN expresion2
Sentencia
----
----
OTHERWISE
Sentencia
----
----
END CASE
3.5.3.-Repetitivas.-
3.5.3.1.- DO WHILE.-
WHILE Condicion
Sentencia
----
----
END WHILE
3.5.3.2.- FOR.-
FOR VariableDeControl = ValorInicial TO ValorFinal [ STEP expresion ]
Sentencia
----
----
END FOR

Pgina 10
3.6.- MANEJO DE MENUS.-

MENU "NombreMenu"
COMMAND [KEY(tecla)] "Opcion1" "Comentario de la opcion 1"
Sentencias
-----
-----
COMMAND [KEY(tecla)] "Opcion2" "Comentario de la opcion 2"
Sentencias
-----
END MENU
Nota: Existen dos sentencias exclusivas en men, es decir, solo se las puede usar
dentro de la estructura menu.
EXIT MENU .- Permite salir del bucle de Menu
NEXT OPTION "Nombre Opcion" .- Hace que la opcin por default sea la indicada
por "nombre opcion"
La clusula KEY en Command permite que la opcin sea seleccionable por la tecla
indicada.
Por default las opciones pueden ser seleccionables por la primer letra de dicha opcin.
Si dos opciones comienzan con la misma letra se utiliza la clusula KEY para definir
otra letra y romper la ambigedad.

Pgina 11
Ejemplo:
{****** MODULO PRINCIPAL DEL SISTEMA DE CONTROL DE ALMACEN *********

******* PROGRAMA SCA_MAIN.4GL *********
******* CopyRight(1995) by Juan Carlos Contreras Villegas *********
}
DATABASE almacen
MAIN
OPEN FORM form_main FROM "f_main"
DISPLAY FORM form_main
MENU "SCA"
COMMAND "Material" "Mantenimiento de materiales"
CALL p_material()
COMMAND key(C) "seCcion" "Mantenimiento de seccion"
CALL p_seccion()
COMMAND "Proveedores" "Mantenimiento de proveedores"
CALL p_proveedor()
COMMAND "Ingresos" "Registrar ingreso de materiales"
CALL p_ingreso()
COMMAND "Egresos" "Registrar egreso de materiales"
CALL p_egreso()
COMMAND "Reportes" "Emitir reportes de la base de datos"
COMMAND "Salir" "Salir del sistema de control de almacen"
EXIT MENU
END MENU
CLOSE FORM f_main
END MAIN

Pgina 12
3.7.- FORMATOS DE PANTALLA.-
Los formatos de pantalla son archivos que contienen texto que sirve de interface
con el usuario. Se puede usar un formato de pantalla junto con las instrucciones de
manipulacin de datos para Ingresar, modificar, consultar y eliminar datos de las
tablas de una base de datos.
El archivo fuente de un formato de pantalla tiene la extensin .PER y su

contenido es texto ASCII.
Para que un archivo de formato de pantalla pueda ser utilizado con un programa
4GL este debe ser compilado y tener una extensin .FRM

Pgina 13
3.7.1.- Estructura de un formato de pantalla.-

Para que un archivo de formato de pantalla sea reconocido debe tener la siguiente
estructura:
DATABASE NombreBaseDeDatos
SCREEN
{
Texto1 [v1 ]
Texto2 [v2 ]
texto3
[v3 ]
TABLES NomTabla1, NomTabla2, ...
ATTRIBUTES
v1 = NomTabla.Columna1, lista de atributos ;
v2 = NomTabla.Columna2, lista de atributos ;
----
----
INSTRUCTIONS
DELIMITERS "ab"
SCREEN RECORD regPant[n] ( tabla.* |
tabla.col1,tabla.col2, ... |
tabla.colX THRU tabla.colY )
END
Un formato de pantalla esta compuesta por cinco secciones que son:

La seccin DATABASE permite especificar la base de datos con la que se va a
trabajar.
La seccin SCREEN permite definir todo lo que se vera en la pantalla. Tambin
permite definir las variables y los campos de pantalla.
La seccin TABLES permite especificar las tablas con las que se interactuara en esta
pantalla.

Pgina 14
La seccin ATTRIBUTES permite asociar las variables de pantalla a un tipo de dato

para su validacin, tambin permite dar o definir algunos atributos a los campos de
la pantalla.
La seccin INSTRUCTIONS permite definir la forma de los delimitadores, por
default son dos parentesis, pero se puede cambiar por dos caracteres. En esta
seccin tambin se permite definir arreglos de pantalla
Se pueden utilizar los siguientes atributos para los campos de pantalla:
AUTONEXT COMMENTS DEFAULT

DOWNSHIFT FORMAT INCLUDE
NOENTRY PICTURE REQUIRED
REVERSE UPSHIFT VERIFY
WORDWRAP ZEROFILL COLOR
AUTONEXT .- Hace que el cursor avance automticamente al siguiente campo

cuando se ha llenado el campo actual.
COLOR = color [WHERE condicion].- Permite especificar los atributos de color

para los datos de los campos. Se desplegara en el color especificado si se cumple la
condicin.
Los colores pueden ser:
WHITE YELLOW MAGENTA RED

CYAN GREEN BLUE BLACK
BLINK REVERSE
COMMENTS = "Comentario" .- Permite desplegar el comentario en la lnea de

comentarios cuando el cursor este en el campo actual.
DEFAULT = Valor .- Permite especificar un valor por defecto para un campo de

despliegue.
DISPLAY LIKE tabla.columna .- permite desplegar los datos en el campo de

acuerdo a una columna de una tabla.
DOWNSHIFT .- hace que los datos del campo sean convertidos en minsculas sin
importar el estado del teclado.

Pgina 15
INCLUDE = ( val1, val2, ... ) .- Permite definir una lista de valores que sern
permitidos para dicho campo. Si se digita un valor que no esta en la lista de valores,
la entrada no ser aceptada. Se utiliza con DEFAULT.
NOENTRY .- Hace que el cursor no entre en este campo evitando la edicin de

dicho campo.
PICTURE = "formato" .- Se utiliza para dar un formato de despliegue de datos, es

muy utilizado para campos de tipo numrico.
se pueden usar los siguientes caractes para formato:
A Permite la entrada de un caracter alfabtico

# Permite el ingreso de un dgito
X Permite el ingreso de cualquier caracter.
REQUIRED .- Obliga a que sea ingresado algun valor para el campo. Si no se

ingresa ningn valor, INFORMIX har que el cursor no pueda moverse a ningn
otro campo.
REVERSE .- Hace que los datos en este campo se muestren en video inverso.
UPSHIFT .- Hace que los datos del campo sean convertidos en maysculas sin
importar el estado del teclado.
VERIFY .- Obliga a que el usuario digite dos veces el mismo dato antes de ser
aceptado.
VALIDATE LIKE tabla.columna .- Permite que INFORMIX valide el dato

ingresado para dicho campo del mismo tipo de dato que la columna de una tabla
especificada.
Ejemplos:
A continuacin mostraremos los formatos de pantalla para la pantalla de presentacin

inicial, y el formato de pantalla para materiales.

Pgina 16
# Formato de pantalla para la pantalla de presentacin del sistema de control de almacn

# NOMBRE : f_main.per
# Designed by : Juan Carlos Contreras Villegas
DATABASE formonly
SCREEN
{
-------------------------------------------------------------------------------
SISTEMA
DE CONTROL
DE ALMACEN
[x]
-------------------------------------------------------------------------------
}
ATTRIBUTES
x=formonly.nada;
INSTRUCTIONS
DELIMITERS " "

Pgina 17
#**** Formato de pantalla para el modulo de materiales

#**** Nombre : f_mate.per
#**** CopyRight (1995) by Juan Carlos Contreras Villegas
DATABASE almacen
SCREEN
{
-------------------------------------------------------------------------------
MATERIALES
=====================
CODIGO [f000]
DESCRIPCION [f001 ]
PRECIO UNITARIO [f002 ]
STOCK MINIMO [f003 ]
CANT [f004 ]
-------------------------------------------------------------------------------
}
end
TABLES Material
ATTRIBUTES
f000 = material.cod_mat,REVERSE,REQUIRED;
f001 = material.descrip,REVERSE,UPSHIFT;
f002 = material.p_unit,REVERSE,NOENTRY;
f003 = material.stock_min,REVERSE,PICTURE="####.###";
f004 = material.cant,REVERSE,NOENTRY;
end
INSTRUCTIONS
DELIMITERS " "

Pgina 18
3.7.2.- Instrucciones para manejo de formatos de pantalla. desde 4GL.-
OPEN FORM var_formato FROM "archivo_formato"

Esta instruccin asocia el nombre de un archivo de formato de pantalla con una
variable 4GL.
DISPLAY FORM var_formato

Permite visualizar el formato de pantalla.
CLEAR FORM
Deja en blanco todos los campos del formato de pantalla.
CLEAR Campo1,campo2, ...

Limpia (deja en nulo ) todos los campos de pantalla especificados.
CLEAR SCREEN
Limpia toda la pantalla.
CLEAR WINDOW nombre_ventana

Limpia el contenido de una ventana especifica.
CLOSE FORM var_formato

Libera la memoria requerida para el formato de pantalla asociado a una variable.
Ejemplo:
Como ejemplo citaremos el procedimiento principal del modulo sca_mate.4gl

Pgina 19
{****** MODULO PRINCIPAL DE MATERIALES ****************

******* MODULO SCA_MATE.4GL ****************
******* CopyRight (1995) by Juan Carlos Contreras Villegas ****************
}
DATABASE almacen
FUNCTION p_material()
OPEN FORM form_mate FROM "f_mate"
DISPLAY FORM form_mate
MENU "MATERIAL"
COMMAND "Altas" "Permite registrar nuevos materiales"
CALL alta_mate()
COMMAND "Bajas" "Permite dar de baja a materiales"
CALL baja_mate()
COMMAND "Modificaciones" "Permite modificar datos de materiales"
CALL modi_mate()
COMMAND "Consultas" "Permite Realizar consultas de materiales".6
CALL cons_mate()
COMMAND "Reportes" "Permite obtener algunos reportes de materiales"
CALL repo_mate()
COMMAND "Salir" "Retorna al menu principal"
EXIT MENU
END MENU
CLEAR SCREEN
CLOSE FORM form_mate
END FUNCTION

Pgina 20
3.8.- CAPTURA DE DATOS.-

La sentencia INPUT permite la captura de datos desde pantalla a travs de un
formato de pantalla. Se puede usar esta sentencia de dos formas:
INPUT BY NAME lista_de_variables [ WITHOUT DEFAULTS ]

BEFORE FIELD NombreCampo
Sentencias
----
----
AFTER FIELD NombreCampo
Sentencias
----
----
AFTER INPUT
Sentencias
----
----
ON KEY (tecla)
Sentencias
----
----
END INPUT
Donde :
lista_de_variables es una lista de variables de programa que tienen el mismo nombre de
los campos declarados en el formato de pantalla.
NombreCampo es el nombre de la columna asociada a las variables de campo del

formato de pantalla
tecla es una tecla o una lista de teclas que pueden ser capturadas, normalmente estas
teclas son teclas de funcion (por Ej. F1) o teclas control (por Ej control-g). Se pueden
usar cualquier tecla excepto control-x,control-h,control-d,control-a,control-l,control-r.
WITHOUT DEFAULTS .- Esta clusula permite desplegar en la pantalla los valores

actuales de la lista de variables.
BEFORE FIELD NombreCampo.- Transfiere el control del programa a las sentencias

especificadas, un instante antes de que el cursor entre al campo especificado.

Pgina 21
AFTER FIELD NombreCampo.- Transfiere el control del programa a las sentencias

especificadas, un instante antes de que el cursor salga del campo especificado.
AFTER INPUT .- Esta clusula transfiere el control del programa a las sentencias
especificadas cuando el el usuario a terminado la introduccin de datos.
ON KEY (tecla) .- Transfiere el control del programa a las sentencias especificadas

cuando el usuario pulse la tecla especificada.
Tambin se pueden utilizar las siguientes sentencias solo dentro de INPUT.

EXIT INPUT.- Permite salir de input inmediatamente.
NEXT FIELD NombreCampo .- Mueve el cursor al campo especificado.
INFIELD(NombreCampo) .- Es una funcin que devuelve verdadero (TRUE) si el cursor

esta en el campo especificado. Devuelve falso (FALSE) en caso contrario.
La segunda forma de escribir esta sentencia es la siguiente.
INPUT lista_de_variables [ WITHOUT DEFAULTS ] FROM lista_de_campos

BEFORE FIELD NombreCampo
Sentencias
----
----
AFTER FIELD NombreCampo
Sentencias
----
----
AFTER INPUT
Sentencias
----
----
ON KEY (tecla)
Sentencias
----
----
END INPUT
En donde: la lista de campos son los campos del formato de pantalla que se asociaran a
las variables de programa.

Pgina 22
Ejemplo:
Como ejemplo realizaremos los procedimientos de Altas, Bajas y modificacin de
materiales
FUNCTION alta_mate()
DEFINE reg RECORD LIKE material.*,
codi LIKE material.cod_mat
MESSAGE "PULSE ESC=Finalizar CTRL-G = Grabar"
INPUT BY NAME reg.*
AFTER FIELD cod_mat
IF reg.cod_mat IS NOT NULL THEN
SELECT cod_mat INTO codi FROM material WHERE cod_mat=reg.cod_mat
IF STATUS<>NOTFOUND THEN
ERROR "Codigo ya existe"
LET reg.cod_mat=NULL
NEXT FIELD cod_mat
END IF
END IF
ON KEY (control-G)
LET reg.p_unit=0
LET reg.cant=0
INSERT INTO material VALUES (reg.*)
CLEAR FORM
INITIALIZE reg.* TO NULL
ERROR Registro grabado
NEXT FIELD cod_mat
END IF
END INPUT
CLEAR FORM
END FUNCTION

Pgina 23
#*************** PERMITE DAR DE BAJA MATERIALES ****************

FUNCTION baja_mate()
DEFINE reg RECORD LIKE material.*,
codi LIKE material.cod_mat
MESSAGE " ESC=Finalizar CTRL-E = Eliminar Registro"
INPUT codi FROM cod_mat
AFTER FIELD cod_mat
IF codi IS NOT NULL THEN
SELECT * INTO reg.* FROM material WHERE cod_mat=codi
IF STATUS=NOTFOUND THEN
ERROR "REGISTRO NO ENCONTRADO"
ELSE
DISPLAY BY NAME reg.*
END IF
END IF
ON KEY (control-e)
IF codi IS NOT NULL THEN
MENU "Eliminar"
COMMAND "No" "No elimina el registro actual"
EXIT MENU
COMMAND "Si" "Elimina el registro actual"
DELETE FROM material WHERE cod_mat=codi
CLEAR FORM
EXIT MENU
END MENU
MESSAGE " ESC=Finalizar CTRL-E = Eliminar Registro"
INITIALIZE codi TO NULL
END IF
END INPUT
END FUNCTION

Pgina 24
#********** PERMITE MODIFICAR DATOS DE MATERIALES ****************

FUNCTION modi_mate()
DEFINE reg RECORD LIKE material.*
MESSAGE " ESC = Salir CTRL-G = Grabar" ATTRIBUTE (REVERSE)
INPUT BY NAME reg.* WITHOUT DEFAULTS
AFTER FIELD cod_mat
SELECT * INTO reg.* FROM material WHERE cod_mat=reg.cod_mat
ERROR "CODIGO NO ENCONTRADO"
NEXT FIELD cod_mat
ELSE
END IF
END IF
ON KEY (control-g)
UPDATE material SET *=(reg.*) WHERE cod_mat=reg.cod_mat
ERROR "REGISTRO ACTUALIZADO"
CLEAR FORM
NEXT FIELD cod_mat
END IF
END INPUT
END FUNCTION

Pgina 25
3.9.- QUERY BY EXAMPLE.-

El Query By Example (Consulta por ejemplos) Es una forma de escribir
programas que permiten recuperar informacin basado en un criterio de bsqueda
que el usuario ingresa con la ayuda de un formato de pantalla.
Para realizar un query by example necesitamos conocer cuatro instrucciones:

- CONSTRUCT (Como el usuario introduce el criterio de bsqueda)
- PREPARE (Como se prepara una sentencia SELECT ejecutable )
- Manejo de cursores
- DISPLAY (como mostrar informacin en la pantalla )
3.9.1.- Como el usuario puede especificar el criterio de busqueda.-

La sentencia que permite al usuario especificar el criterio de bsqueda es
CONSTRUCT. La sentencia CONSTRUCT permite crear una variable CHAR (string)
que contiene la condicin para la clusula WHERE de la sentencia SELECT.
La sentencia CONSTRUCT se puede usar de dos formas:

Sintaxis:
1) CONSTRUCT varString ON lista_de_columnas FROM lista_de_campos
2) CONSTRUCT BY NAME varString ON lista_de_columnas
Donde :
varString .- Es la variable varString es una variable de programa de tipo CHAR.
lista_de_columnas .- Es una lista de las columnas de la o las tablas sobre las que se
hara la consulta.
lista_de_campos .- Es una lista de uno o mas campos del formato de pantalla
En la segunda forma de usar CONSTRUCT la lista de columnas debe tener el

mismo nombre de la lista de campos del formato de pantalla.
El usuario puede usar algunos operadores para especificar su criterio de

bsqueda.

Pgina 26
Operador Significado Tipos de dato Sintaxis Ejemplo

= Igual a todos =dato =5
> Mayor que todos >dato >500
< Menor que todos <dato <300
>= Mayor o igual que todos >=dato >=200
<= Menor o igual que todos <=dato <=400
<> Diferente de todos <>dato <>200
: Rango todos v_ini : val_fin 100:400
* comodin (Cualquier Caracter) CHAR *x, x*,*x* *JUAN*
? Comodin (un caracter) CHAR ?x,x?,?x?,x?? ?AR?A
| O ( OR ) todos a | b | c | ... 2 | 3 | 4 | 20
Ejemplo:
DEFINE cons,consu CHAR (300)

CONSTRUCT BY NAME cons ON material.*
LET consu = "SELECT * FROM material WHERE ",cons CLIPPED
Si el usuario digita [ > 300 ] en el campo cod_mat y [ > 100 ] en el campo stock_min,
la variable cons despus de CONSTRUCT tendr el siguiente valor
cons = "material.cod_mat > 300 AND material. stock_min > 100". Luego la sentencia
LET permite tener en la variable consu un cadena que contiene la consulta, y su
resultado sera:
consu = "SELECT * FROM material WHERE material.cod_mat > 300 AND
material.stock_min > 100".
3.9.2.- Como se prepara la sentencia SELECT ejecutable.-

Recordemos de el ejemplo anterior que la variable consu contiene un cadena en la
que esta definida la consulta, pero esta cadena no puede ser ejecutada. La sentencia
PREPARE permite crear una sentencia ejecutable a partir de un string.
Sintaxis:
PREPARE NombreSentencia FROM varString
Ejemplo:
PREPARE consu_mate FROM consu

Para poder ejecutar una sentecia SQL se puede utilizar la sentencia EXECUTE
(Ejemplo EXECUTE consu_mate), esto hara que se ejecute la sentencia SELECT.

Pgina 27
3.9.3.- Manejo de cursores.-

Los cursores con archivos temporales que se crean debido a una consulta, y que
pueden ser manipulados. Existen dos clases de cursores : secuencial y el SCROLL
CURSOR (acceso directo).
3.9.3.1.- SCROLL CURSOR.-

Un SCROLL CURSOR tiene cuatro propiedades:
Situar el puntero al primer registro, Situar el puntero en el ultimo registro, situar el
puntero en el anterior y situar el puntero en el siguiente registro.
Las sentencias para manipular los cursores son los siguientes:

DECLARE NombreCursor SCROLL CURSOR FOR Select . . .
Crea el cursor a partir de la consulta.
OPEN NombreCursor
Abre el cursor y posiciona el puntero antes del primer registro
FETCH FIRST NombreCursor INTO lista_de_variables
Posiciona el puntero en el primer registro del cursor y recupera sus datos en las
variables especificadas en la lista de variables.
FETCH LAST NombreCursor INTO lista_de_variables
Posiciona el puntero del cursor en el ultimo registro y recupera sus datos en las
variables especificadas en la lista de variables
FETCH NEXT NombreCursor INTO lista_variables
variables especificadas en la lista de variables
FETCH PREVIOUS NombreCursor INTO lista_de_variables
variables especificadas en la lista de variables.
CLOSE NombreCursor
Cierra el cursor (destruye el archivo temporal).

Pgina 28
3.9.3.2.- CURSOR secuencial.-

Las sentencias que permiten manipular cursores secuenciales son las siguientes.
DECLARE NombreCursor CURSOR FOR Select ...
Crea el cursor a partir de la consulta.
FOREACH NombreCursor INTO lista_de_variables
Senetencias
----
----
END FOREACH
La sentencia FOREACH avanza el cursor registro a registro recuperando los datos del
cursor en las variables especificadas por la lista de variables. Es una especie de WHILE
NOT EOF DO
3.9.4.- Ejemplo) Como ejemplo citaremos los procedimientos de consulta de

materiales.

Pgina 29
#***** PROCEDIMIENTO QUE PERMITE REALIZAR CONSULTAS DE MATERIALES *******

FUNCTION cons_mate()
DEFINE cons,consu CHAR (300),
reg RECORD LIKE material.*
MESSAGE "Presione ESC para efectuar la consulta"

CONSTRUCT BY NAME cons ON material.* #construye las especificaciones del usr.
LET consu="SELECT * FROM material WHERE ",cons CLIPPED

PREPARE cons_mate FROM consu #prepara la consulta
DECLARE q_mat SCROLL CURSOR FOR cons_mate

OPEN q_mat
FETCH FIRST q_mat INTO reg.*
IF STATUS<>NOTFOUND THEN
MENU "VER"
COMMAND "Primero" "Ver el primer registro de la consulta"
FETCH FIRST q_mat INTO reg.*
COMMAND KEY (R) "pRoximo" "Ver Siguiente registro de la consulta"
FETCH NEXT q_mat INTO reg.*
ERROR "No hay mas registros hacia adelante"
ELSE
END IF
COMMAND "Anterior" "Ver anterior registro de la consulta"
FETCH PREVIOUS q_mat INTO reg.*
ERROR "No hay mas registros hacia atras"
ELSE
END IF
COMMAND "Ultimo" "Ver el ultimo registro de la consulta"
FETCH LAST q_mat INTO reg.*
COMMAND "Salir" "Retornar al menu de Materiales"
EXIT MENU
END MENU
ELSE
ERROR "Ningun registro fue encontrado con las especificaciones dadas"
END IF
CLOSE q_mat
CLEAR FORM
END FUNCTION

Pgina 30
3.10.- REPORTES.-
Para poder obtener un reporte es necesario seguir 2 pasos: construir el reporte, y dar
formato al reporte.
3.10.1.- Construccion del reporte.-

Para poder ejecutar un reporte primero se debe seleccionar la informacin que se
desea, luego se construiye el reporte.
Para seleccionar la informacion para el reporte se debe realizarlo mediante la

sentencia SELECT y uso de Cursores.
Para construir el reporte se procede de la siguiente forma:
START REPORT NombreFuncReporte [TO "nomarch" | TO PRINTER ]

bucle
sentencias
-------
-------
OUTPUT TO REPORT NombreFuncReporte (lista de parametros)
fin bucle
FINISH REPORT NombreFuncReporte

Pgina 31
3.10.2.- Formato del reporte.

REPORT NombreFuncReporte ( lista_de_argumentos )
DEFINE lista_de_argumentos # se define el tipo de dato de los argumentos
DEFINE lista_de_variables # se define las variables para el reporte
OUTPUT
REPORT [ TO "nombre archivo" | TO PRINTER ]
LEFT MARGIN n # margen izquierdo (Default=5)
RIGHT MARGIN n # ancho de pagina en caracteres. Solo es efectivo si se
# utiliza la sentencia EVERY ROW (Default=132)
TOP MARGIN n # margen superior (en lneas) (Default=3 lneas)
BOTTOM MARGIN n # margen inferior ( en lneas ) (Default=3
lneas)
PAGE LENGTH n # Longitud de pagina (en lneas) (Default=66 lneas)
FORMAT
FIRST PAGE HEADER # encabezado para la primer pagina
Sentencia
----
----
PAGE HEADER # encabezado para todas las paginas
Sentencia
----
----
ON EVERY ROW # cada registro que le llega
Sentencia
-----
PAGE TRAILER # pie de pagina
Sentencia
-----
-----
BEFORE GROUP OF variable # Subttulos ( Antes que se ejecute ON EVERY
Sentencia # ROW)
----
AFTER GROUP OF variable # Sub pie de pagina (despus que se haya ejecutado
Sentencia # ON EVERY ROW)
----
ON LAST ROW # Especifica lo que Informix har despus que se haya
Sentencia # procesado la ltima lnea que recibi REPORT
----
END REPORT

Pgina 32
Donde n es un numero literal, es decir, n no puede ser una variable
Margen superior ->

Titulo o encabezado de cada pagina
PAGE HEADER
----------------------------------------------
Subtitulo: BEFORE GROUP OF
Lineas de detalle : ON EVERY ROW
-----------------
-----------------
Subpie de pagina: AFTER GROUP OF
Logitud de pagina
Subtitulo: BEFORE GROUP OF
Lineas de detalle : ON EVERY ROW
-----------------
-----------------
Subpie de pagina: AFTER GROUP OF
----------------------------------------------
Pie de pagina
PAGE TRAILER
Margen inferior ->
RIGHT MARGIN
(Ancho de pagina en caracters)
Sentencias que se utilizan en la funcion reporte

PRINT lista_de_expresiones
Ejemplo)
PRINT p_unit, " ",catidad
SKIP n LINES # salta n lineas o imprime n lineas en blanco (n es una constante literal)
PAUSE "mensaje" # muestra un mensaje mientras se detiene un instante

clausula COLUMN
COLUMN n # avanza el cabezal de la impresora hasta la columna n
Ejemplo)
PRINT "Hola", COLUMN 20, PAGENO USING "###"

Pgina 33
Variables y funciones que se pueden utilizar en una funcion de formato de reporte.
PAGENO # Numero de pagina

LINENO # numero de linea { 0 .. (PAGE LENGHT -1) }
TODAY # fecha del sistema
GROUP COUNT (expresion) [ WHERE Condicion ] #cuenta las expresiones que

cumplen con la condicin dentro de un grupo.
GROUP SUM (expresion) [ WHERE Condicion ] #suma la expresin en el grupo
GROUP AVG (expresion) [ WHERE Condicion ] # calcula el promedio del grupo
GROUP MIN (expresion) [ WHERE Condicion ] #calcula el menor de la expresin
GROUP MAX (expresion) [ WHERE Condicion ] #calcula el mayor de la expresin
Las funciones GROUP se utilizan normalmente en la seccin AFTER GROUP OF
Ejemplo)
Como un primer ejemplo se citara el programa de reporte de materiales.
#******* FUNCION QUE PERMITE SELECCIONAR EL ORDEN DEL REPORTE *****

FUNCTION repo_mate()
MENU "Reporte ordenado por"
COMMAND "Codigo" "Reporte de materiales ordenado por codigo"
CALL repo_mate1("C")
COMMAND "Descripcion" "Reporte de materiales ordenado por descripcion"
CALL repo_mate1("D")
COMMAND "Salir" "Retornar al menu de materiales"
EXIT MENU
END MENU
END FUNCTION
#* PROCESO QUE SELECCIONA EL DISPOSITIVO DE SALIDA PARA EL REPORTE **

FUNCTION repo_mate1(orden)
DEFINE orden CHAR(1)
MENU "REPORTE DE MATERIALES - Salida por"
COMMAND "Pantalla" "Salida por pantalla"
CALL repo_mat_pant(orden)
COMMAND "Impresora" "Salida por impresora"
CALL repo_mat_impr(orden)
COMMAND "Salir" "Retorna a Seleccionar orden en reporte de materiales"
EXIT MENU
END MENU
END FUNCTION

Pgina 34
#***** PROCESO QUE CONSTRUYE EL REPORTE POR PANTALLA ******

FUNCTION repo_mat_pant(orden)
DEFINE orden CHAR(1), titulo CHAR(11), reg RECORD LIKE material.*,
cons CHAR(100)
IF orden="C" THEN
LET cons="SELECT * FROM material ORDER BY cod_mat"
LET titulo="CODIGO"
ELSE
LET cons="SELECT * FROM material ORDER BY descrip"
LET titulo="DESCRIPCION"
END IF
PREPARE consu FROM cons
DECLARE q_mat2 CURSOR FOR consu
START REPORT rep1_mate
FOREACH q_mat2 INTO reg.*
OUTPUT TO REPORT rep1_mate(reg.*,titulo)
END FOREACH
FINISH REPORT rep1_mate
END FUNCTION
#***** PROCESO QUE CONSTRUYE EL REPORTE POR IMPRESORA ******

FUNCTION repo_mat_impr(orden)
DEFINE orden CHAR(1), titulo CHAR(11), reg RECORD LIKE material.*,
cons CHAR(100)
IF orden="C" THEN
LET cons="SELECT * FROM material ORDER BY cod_mat"
LET titulo="CODIGO"
ELSE
LET cons="SELECT * FROM material ORDER BY descrip"
LET titulo="DESCRIPCION"
END IF
PREPARE conti FROM cons
DECLARE q_mat5 CURSOR FOR conti
START REPORT rep2_mate TO PRINTER
FOREACH q_mat5 INTO reg.*
OUTPUT TO REPORT rep2_mate(reg.*,titulo)
END FOREACH
FINISH REPORT rep2_mate
END FUNCTION

Pgina 35
#************** FORMATO DE REPORTE POR PANTALLA **************

REPORT rep1_mate(reg,titulo)
DEFINE reg RECORD LIKE material.*,titulo CHAR(11)
OUTPUT # margenes
LEFT MARGIN 0
TOP MARGIN 0
BOTTOM MARGIN 0
PAGE LENGTH 21
FORMAT
PAGE HEADER # titulo para todas las paginas
PRINT "Hospital Japones REPORTE DE MATERIALES",COLUMN 64,
"FECHA : ",TODAY USING "dd/mm/yy"
PRINT "Seccion Almacen ORDENADO POR ",titulo,COLUMN 64,
"Pagina : ",PAGENO USING "####"
PRINT "---------------------------------------------------------",
"---------------------"
PRINT "CODIGO DESCRIPCION PRECIO UNIT. STOCK ",
"STOCK MINIMO"
PRINT "---------------------------------------------------------",
"---------------------"
ON EVERY ROW # linea de detalle
PRINT reg.cod_mat, USING "#### ",
reg.descrip," ",
reg.p_unit USING "#,##&.&& ",
reg.cant USING "#,##&.&&& ",
reg.stock_min USING "#,##&.&&&"
PAGE TRAILER # pie de pagina

PAUSE "Pulse una tecla para continuar"
ON LAST ROW # despues de la ultima linea procesada

PRINT "---------------------------------------------------------",
"---------------------"
PRINT COLUMN 50,"TOTAL --> ",SUM(reg.cant*reg.p_unit)
END REPORT

Pgina 36
#************** FORMATO DE REPORTE POR IMPRESORA **************

REPORT rep2_mate(reg,titulo)
DEFINE reg RECORD LIKE material.*,titulo CHAR(11)
OUTPUT # margenes
LEFT MARGIN 0
TOP MARGIN 0
BOTTOM MARGIN 0
FORMAT
PAGE HEADER # Titulo para cada pagina

PRINT "Hospital Japones REPORTE DE MATERIALES",COLUMN 64,
"FECHA : ",TODAY USING "dd/mm/yy"
PRINT "Seccion Almacen ORDENADO POR ",titulo,COLUMN 64,
"Pagina : ",PAGENO USING "####"
PRINT "---------------------------------------------------------",
"---------------------"
PRINT "CODIGO DESCRIPCION PRECIO UNIT. STOCK ",
"STOCK MINIMO"
PRINT "---------------------------------------------------------",
"---------------------"
ON EVERY ROW # Linea de detalle

PRINT reg.cod_mat," ",
reg.descrip," ",
reg.p_unit USING "#,##&.&& ",
reg.cant USING "#,##&.&&& ",
reg.stock_min USING "#,##&.&&&"
ON LAST ROW # Despues de haber procesado la ultima lnea

PRINT "---------------------------------------------------------",
"---------------------"
PRINT COLUMN 50,"TOTAL --> ",SUM(reg.cant*reg.p_unit)
END REPORT

Pgina 37
3.11.- MANEJO DE ARREGLOS CON FORMATOS DE PANTALLA.-
Ingresos : Ingresar Anular Consultar Salir

Permite realizar las notas de ingreso de materiales
---------------------------------------------------------------------------------------------------
Hospital Japones INGRESOS Nro.Ingreso
Seccion Almacen DE MATERIALES Fecha :
Proveedor
CODIGO DESCRIPCION PRECIO UNIT.CANTIDAD MONTO
---------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------
TOTAL - >
---------------------------------------------------------------------------------------------------
Para poder trabajar con datos que estn en mltiples filas (varios tems) es hace
necesario
asociar un arreglo de programa con un arreglo de pantalla.
Como Ejemplo citaremos el formato de pantalla para registrar los ingresos de

materiales.

Pgina 38
#****** FORMATO DE PANTALLA PARA INGRESOS DE MATERIALES ******

#****** FORMATO F_ING.PER ******
DATABASE Almacen
SCREEN
{
-----------------------------------------------------------------------------------
Hospital JAPONES INGRESOS Nro.Ingreso [c1 ]
Seccion Almacen DE MATERIALES Fecha : [c2 ]
Proveedor [c3 ] [c4 ]

CODIGO DESCRIPCION PRECIO UNIT. CANTIDAD MONTO
-----------------------------------------------------------------------------------
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
------------------------------------------------------------------------------------
Total -> [c10 ]
------------------------------------------------------------------------------------
}
TABLES ingreso,proveedor,material,mat_ing
ATTRIBUTES
c1 = ingreso.nro_ing,REVERSE;
c2 = fecha,REVERSE;
c3 = proveedor.cod_prov,REVERSE;
c4 = nombre,REVERSE,UPSHIFT,NOENTRY;
c5 = material.cod_mat,REVERSE;
c6 = descrip,REVERSE,UPSHIFT,NOENTRY;
c7 = mat_ing.p_unit,REVERSE;
c8 = mat_ing.cant,REVERSE;
c9 = formonly.monto TYPE DECIMAL(10,2),REVERSE,NOENTRY;
c10 = formonly.montoTot TYPE DECIMAL(10,2),REVERSE,NOENTRY;
INSTRUCTIONS
DELIMITERS " "
SCREEN RECORD arr_ing[8] ( material.cod_mat, descrip, mat_ing.p_unit, mat_ing.cant,
formonly.monto )

Pgina 39
3.11.1.- Instrucciones para manejo de arreglos con formatos de pantalla.-

Captura de datos en arreglos.-
INPUT ARRAY arr_prog [ WITHOUT DEFAULTS ] FROM arr_pant.*
BEFORE FIELD NomCampo
Sentencias # Estas sentencias se ejecutaran un instante
-------------- # antes de que el cursor entre al campo
-------------- # especificado.
AFTER FIELD NomCampo
Sentencias # Estas sentencias se ejecutaran cuando
-------------- # el cursor intente salir del campo
-------------- # especificado
BEFORE INSERT
Sentencias # Estas sentencias se ejecutaran antes de
-------------- # insertar una nueva fila
--------------
AFTER INSERT
Sentencias # Estas sentencias se ejecutaran despues
-------------- # de que se haya insertado una nueva fila
--------------
BEFORE DELETE
Sentencias # Estas sentencias se ejecutaran antes de
-------------- # suprimir una fila del arreglo
--------------
AFTER DELETE
Sentencias # Estas sentencias se ejecutaran despues
-------------- # de suprimir una fila del arreglo
--------------
BEFORE ROW
Sentencias # Estas sentencias se ejecutaran antes que
-------------- # el cursor entre a una fila
--------------
AFTER ROW
-------------- # el cursor esta saliendo de una fila
--------------
ON KEY (tecla)
-------------- # se pulse la tecla especificada
--------------
END INPUT

Pgina 40
Mostrar datos de arreglos en pantalla
DISPLAY ARRAY ArrayProg TO ArrPant.*

ON KEY (tecla)
-----------
-----------
END DISPLAY
3.11.2- Funciones y procedimientos para manejo de arreglos.-

SCR_LINE() .- Funcin que devuelve la posicin de fila en la que se encuentra el
cursor en el arreglo de pantalla.
ARR_CURR() .- Funcin que devuelve la posicin de fila en la que se encuentra el

cursor en el arreglo de programa.
ARR_COUNT() .- Funcin que devuelve el numero de filas llenas que tiene el arreglo
de programa.
SET_COUNT(n) .- Procedimiento que le informa a INFORMIX el numero de filas

llenas que tiene un arreglo de programa. Este dato ser utilizado para desplegar datos
de arreglos en pantalla.
Ingresos : Ingresar Anular Consultar Salir

Permite realizar las notas de ingreso de materiales
---------------------------------------------------------------------------------------------------
Hospital Japones INGRESOS Nro.Ingreso
Seccion Almacen DE MATERIALES Fecha :
Proveedor
CODIGO DESCRIPCION PRECIO UNIT.CANTIDAD MONTO
---------------------------------------------------------------------------------------------------
100 D
200 E
300 F
---------------------------------------------------------------------------------------------------
TOTAL - >
---------------------------------------------------------------------------------------------------

Pgina 41
DATABASE Almacen
SCREEN
{
---------------------------------------------------------------------------------------------------------
Hospital JAPONES INGRESOS Nro.Ingreso [c1 ]
Seccion Almacen DE MATERIALES Fecha: [c2 ]
Proveedor [c3 ] [c4 ]

CODIGO DESCRIPCION PRECIO UNIT. CANTIDAD MONTO
---------------------------------------------------------------------------------------------------------
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
[c5 ] [c6 ] [c7 ] [c8 ] [c9 ]
---------------------------------------------------------------------------------------------------------
Total -> [c10 ]
---------------------------------------------------------------------------------------------------------
}
TABLES ingreso,proveedor,material,mat_ing
ATTRIBUTES
c1 = ingreso.nro_ing,REVERSE;
c2 = fecha,REVERSE;
c3 = proveedor.cod_prov,REVERSE;
c4 = nombre,REVERSE,UPSHIFT,NOENTRY;
c5 = mat_ing.cod_mat,REVERSE;
c6 = descrip,REVERSE,UPSHIFT,NOENTRY;
c7 = mat_ing.p_unit,REVERSE;
c8 = mat_ing.cant,REVERSE;
c9 = formonly.monto TYPE DECIMAL(10,2),REVERSE,NOENTRY;
c10= formonly.montoTot TYPE DECIMAL(10,2),REVERSE,NOENTRY;
INSTRUCTIONS
DELIMITERS " "
SCREEN RECORD arr_ing[8] (mat_ing.cod_mat, descrip, mat_ing.p_unit,cant,
formonly.monto)

Pgina 42
DATABASE almacen
MAIN
DEFER QUIT
OPTIONS INPUT WRAP
CALL p_ingreso()
END MAIN
FUNCTION p_Ingreso()
OPEN FORM f_ing FROM "f_ing"
DISPLAY FORM f_ing
MENU "Ingresos"
COMMAND "Ingresar" "Registrar Notas de ingreso"
CALL ingresar()
COMMAND "Anular" "Anular notas de ingreso emitidas"
COMMAND "Consultar" "Revisar notas de ingreso anteriores"
COMMAND "Salir" "Salir del modulo de Ingresos"
EXIT MENU
END MENU
CLOSE FORM f_ing
END FUNCTION
FUNCTION ingresar()
DEFINE salir SMALLINT,
regi RECORD
nro_ing INTEGER,
fecha DATE,
cod_prov LIKE proveedor.cod_prov,
nombre LIKE proveedor.nombre
END RECORD
LET salir=false
INITIALIZE regi.* TO NULL
WHILE NOT salir
MESSAGE "^I=Editar Items ESC=Retornar al Menu Principal"
CALL PedirEncabezado(regi.*) RETURNING regi.*,salir
IF NOT salir THEN
CALL PedirDetalle(regi.*) RETURNING regi.*, salir
END IF
END WHILE
END FUNCTION

Pgina 43
FUNCTION PedirEncabezado(regi)
regi RECORD
nro_ing INTEGER,
fecha DATE,
END RECORD,
nroi INTEGER
LET salir=TRUE
INPUT BY NAME regi.* WITHOUT DEFAULTS
AFTER FIELD nro_ing
IF regi.nro_ing IS NOT NULL THEN
SELECT nro_ing INTO nroi FROM ingreso where nro_ing=regi.nro_ing
IF STATUS <> NOTFOUND THEN
ERROR "Nota de ingreso ya fue registrada"
NEXT FIELD nro_ing
END IF
END IF
AFTER FIELD cod_prov
IF regi.cod_prov IS NOT NULL THEN
SELECT nombre INTO regi.nombre FROM proveedor
WHERE cod_prov=regi.cod_prov
ERROR "Proveedor no ha sido registrado"
NEXT FIELD cod_prov
ELSE
DISPLAY BY NAME regi.nombre
END IF
END IF
ON KEY (control-I)
LET salir=FALSE
EXIT INPUT
END INPUT
RETURN regi.*,salir
END FUNCTION

Pgina 44
FUNCTION PedirDetalle(regi)
regi RECORD
nro_ing INTEGER,
fecha DATE,
END RECORD,
VIng ARRAY [50] OF RECORD

cod_mat LIKE material.cod_mat,
descrip LIKE material.descrip,
p_unit LIKE mat_ing.p_unit,
cant LIKE mat_ing.cant,
monto LIKE mat_ing.p_unit
END RECORD,
montoTot MONEY(10),
i,j,n SMALLINT,
canti LIKE mat_ing.cant,
p_uni LIKE mat_ing.p_unit
MESSAGE "ESC=Retornar al Menu ^G=Registrar INGRESO ^V=Volver atras"

LET salir=TRUE
FOR i=1 TO 50
INITIALIZE Ving[i].* TO NULL
END FOR
# CALL set_count(0)
CLEAR arr_ing.*
INPUT ARRAY Ving FROM arr_ing.*
AFTER FIELD cod_mat
LET i=arr_curr()
LET j=scr_line()
IF Ving[i].cod_mat IS NOT NULL THEN
SELECT descrip INTO ving[i].descrip FROM material
WHERE cod_mat=ving[i].cod_mat
IF STATUS = NOTFOUND THEN
ERROR "Material todavia no fue registrado"
INITIALIZE ving[i].* TO NULL
NEXT FIELD cod_mat
ELSE
DISPLAY ving[i].descrip,ving[i].p_unit TO
arr_ing[j].descrip,arr_ing[j].p_unit
END IF

Pgina 45
END IF
AFTER FIELD p_unit,cant
LET i=arr_curr()
LET j=scr_line()
LET ving[i].monto=ving[i].p_unit*ving[i].cant
DISPLAY ving[i].monto TO arr_ing[j].monto
AFTER DELETE
LET n=arr_count()
LET montoTot=0
FOR i=1 TO n
IF (ving[i].p_unit IS NOT NULL) AND (ving[i].cant IS NOT NULL) THEN
LET montoTot=montoTot + ving[i].p_unit*ving[i].cant
END IF
END FOR
DISPLAY BY NAME montoTot
AFTER ROW
LET n=arr_count()
LET montoTot=0
FOR i=1 TO n
IF (ving[i].p_unit IS NOT NULL) AND (ving[i].cant IS NOT NULL) THEN
LET montoTot=montoTot + ving[i].p_unit*ving[i].cant
END IF
END FOR
DISPLAY BY NAME montoTot
ON KEY (control-v)
LET salir=FALSE
EXIT INPUT
ON KEY (control-G)
LET n=arr_count()
LET j=0
FOR i=1 TO n
IF ving[i].cod_mat IS NOT NULL THEN
LET j=j+1
IF ving[i].p_unit IS NULL THEN
LET ving[i].p_unit=0
END IF
IF ving[i].cant IS NULL THEN
LET ving[i].cant=0
END IF
SELECT MAX(nro_ing)+1 INTO regi.nro_ing FROM ingreso
IF regi.nro_ing IS NULL THEN
LET regi.nro_ing=0
END IF
INSERT INTO mat_ing VALUES (regi.nro_ing,ving[i].cod_mat,

Pgina 46
ving[i].cant,ving[i].p_unit)
SELECT cant,p_unit INTO canti,p_uni FROM material
WHERE cod_mat=ving[i].cod_mat
LET p_uni=((canti*p_uni) + (ving[i].cant*ving[i].p_unit))/
(canti+ving[i].cant)
LET canti=canti+ving[i].cant
UPDATE material set cant=canti,p_unit=p_uni
END IF
END FOR
IF j>0 THEN
INSERT INTO ingreso (fecha,cod_prov,anulado) VALUES
(regi.fecha,regi.cod_prov,"0")
ERROR "el INGRESO fue registrado"
LET Salir=FALSE
CLEAR FORM
EXIT INPUT
ELSE
ERROR "No hay Items validos. el INGRESO no fue registrado"
END IF
END INPUT
RETURN regi.*, salir
END FUNCTION

Pgina 47
{*** Procedimiento que permite revisar notas de ingreso e imprimirlas ****}

FUNCTION cons_ingr()
DEFINE regi RECORD
nro_ing INTEGER, fecha DATE, cod_prov LIKE proveedor.cod_prov,
nombre LIKE proveedor.nombre,
anulado CHAR(1)
END RECORD
MESSAGE "^P = Imprimir Notas ESC = Retornar al Menu Principal"
INPUT BY NAME regi.nro_ing
AFTER FIELD nro_ing
CLEAR FORM
IF regi.nro_ing IS NOT NULL THEN
SELECT fecha,cod_prov,anulado INTO regi.fecha,regi.cod_prov,
regi.anulado FROM ingreso WHERE nro_ing=regi.nro_ing
CLEAR FORM
ERROR "Nota de ingreso no fue encontrado"
ELSE
SELECT nombre INTO regi.nombre FROM proveedor
WHERE cod_prov=regi.cod_prov
DISPLAY BY NAME regi.nro_ing THRU regi.nombre
CALL mostrarDetalle(regi.*)
END IF
END IF
END INPUT
CLEAR FORM
END FUNCTION

Pgina 48
{*** PROCESO QUE MUESTRA LOS ITEMS DE LA NOTA DE INGRESO ***}

FUNCTION mostrarDetalle(regi)
DEFINE regi RECORD
nro_ing INTEGER,
fecha DATE,
anulado CHAR(1)
END RECORD,
VIng ARRAY [50] OF RECORD

END RECORD,
montoTot MONEY(10),
i,n SMALLINT
DECLARE q1_ing CURSOR FOR SELECT

mi.cod_mat,m.descrip,mi.p_unit,mi.cant, mi.p_unit*mi.cant
FROM mat_ing mi,material m
WHERE (nro_ing=regi.nro_ing) AND (mi.cod_mat=m.cod_mat)
LET i=1
LET montoTot=0
FOREACH q1_ing INTO ving[i].*
LET montoTot=montoTot + (ving[i].p_unit*ving[i].cant)
LET i=i+1
END FOREACH
LET n=i-1
IF n>0 THEN
CALL set_count(n)
DISPLAY ARRAY ving TO arr_ing.*
ON KEY (control-p)
CALL print_ing(regi.*)
END DISPLAY
END IF
END FUNCTION

Pgina 49
{*** PROCESO QUE PERMITE IMPRIMIR LA NOTA DE INGRESO ***}
FUNCTION print_ing(regi)
DEFINE regi RECORD
nro_ing INTEGER,
fecha DATE,
anulado CHAR(1)
END RECORD,
regd RECORD
END RECORD
DECLARE q2_ing CURSOR FOR SELECT
mi.cod_mat,m.descrip,mi.p_unit,mi.cant,
mi.p_unit*mi.cant FROM mat_ing mi,material m
WHERE (nro_ing=nroi) AND (mi.cod_mat=m.cod_mat)
START REPORT nota_ing

FOREACH q2_ing INTO regd.*
OUTPUT TO REPORT nota_ing(regi.*,regd.*)
END FOREACH
FINISH REPORT nota_ing
END FUNCTION

Pgina 50
{*** PROCESO QUE FORMATO A LA NOTA DE INGRESO IMPRESA ***}

REPORT nota_ing(regi,regd)
DEFINE regi RECORD
nro_ing INTEGER,
fecha DATE,
anulado CHAR(1)
END RECORD,
regd RECORD
END RECORD
OUTPUT
LEFT MARGIN 0
TOP MARGIN 0
BOTTOM MARGIN 0
PAGE LENGTH 21
FORMAT
PAGE HEADER
PRINT "Hospital XYZ",COLUMN 32,"NOTA DE ENTREGA",
COLUMN 69,"Nro.",regi.nro_ing USING "######"
PRINT "Seccion ALMACEN",COLUMN 63,"FECHA: ",
regi.fecha USING "dd/mm/yyyy"
PRINT regi.cod_prov USING "#### ",regi.nombre
PRINT "--------------------------------------------------------------"
PRINT "ITEM DESCRIPCION P.UNIT CANTIDAD MONTO"
PRINT "--------------------------------------------------------------"
ON EVERY ROW
PRINT regd.cod_mat USING "#### ",regd.descrip,
regd.p_unit USING " #,##&.&& ", regd.cant USING "#,###&.&&& ",
regd.monto USING "##,##&.&&"
ON LAST ROW
PRINT "--------------------------------------------------------------"
PRINT COLUMN 60,"Total ",SUM(regd.cant*regd.p_unit) USING "#,##&.&&"
END REPORT

Pgina 51

00 Informix 4gl Espanol2 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

00 Informix 4gl Espanol2 PDF

Cargado por

Copyright:

Formatos disponibles

VS

(c) Derechos Reservados

III PROGRAMACION EN INFORMIX-4GL

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

4GL .- Four Generation Language (Lenguaje de programacin de cuarta

INFORMIX-4GL es un lenguaje de cuarta generacin muy poderoso que provee

INFORMIX-4GL consta de:

2.- Que es una Base de datos ?

3.- Que es una tabla ?

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

El ejemplo planteado para el presente curso es un sistema de control de almacn

Base de datos ALMACEN

cod_sec descrip fecha nro_egr

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

Descripcin de las tablas para la base de datos ALMACEN

nro_egr fecha cod_sec

nro_egr cod_mat cant p_unit

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

SQL + Estructuras de control + Formatos de pantalla + Reportes = 4GL

3.1.-- ESTRUCTURA DE UN PROGRAMA 4GL.-

FUNCTION NombreFuncion(lista de argumentos)

REPORT NombreFuncionReporte(lista de argumentos)

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

En un programa 4GL existen 5 secciones, las cuales se detallan a continuacin:

Seccin DATABASE.- En esta seccin se especifica el nombre de la base de datos con la

Seccin MAIN .- En esta seccin se escriben la instrucciones.

Seccin FUNCTION.- Se pueden definir las funciones o procedimientos que seran

El sistema a desarrollar se llamara SCA (Sistema de control de almacn) y estar

sca_mate sca_prove sca_secc sca_ingr sca_egre sca_repo

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

El diseo de pantalla para el sistema ser el siguiente:

3.2.- TIPOS DE DATOS.-

3.2.1.-Tipos de dato simples-

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

3.2.2.-Tipos de dato compuestos.-

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

INITIALIZE var1,var2,... TO NULL

La sentencia LET permite asignar el valor de una expresion a una variable.

En este ejemplo se han escrito 2 sentencias, la sentencia 1 (INITIALIZE )ocupa dos

3.5.2.1.- Alternativa simple.-

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

3.6.- MANEJO DE MENUS.-

EXIT MENU .- Permite salir del bucle de Menu

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

{****** MODULO PRINCIPAL DEL SISTEMA DE CONTROL DE ALMACEN *********

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

3.7.- FORMATOS DE PANTALLA.-

El archivo fuente de un formato de pantalla tiene la extensin .PER y su

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

3.7.1.- Estructura de un formato de pantalla.-

TABLES NomTabla1, NomTabla2, ...

Un formato de pantalla esta compuesta por cinco secciones que son:

Ing. Juan Carlos Contreras Villegas U.A.G.R.M.-INFORMATICA

La seccin ATTRIBUTES permite asociar las variables de pantalla a un tipo de dato

Se pueden utilizar los siguientes atributos para los campos de pantalla:

AUTONEXT COMMENTS DEFAULT

AUTONEXT .- Hace que el cursor avance automticamente al siguiente campo

COLOR = color [WHERE condicion].- Permite especificar los atributos de color

WHITE YELLOW MAGENTA RED

COMMENTS = "Comentario" .- Permite desplegar el comentario en la lnea de

DEFAULT = Valor .- Permite especificar un valor por defecto para un campo de

DISPLAY LIKE tabla.columna .- permite desplegar los datos en el campo de

{ MODULO PRINCIPAL DEL SISTEMA DE CONTROL DE ALMACEN ***

{ MODULO PRINCIPAL DE MATERIALES **********

#* PERMITE DAR DE BAJA MATERIALES **

# PERMITE MODIFICAR DATOS DE MATERIALES ******

#* PROCEDIMIENTO QUE PERMITE REALIZAR CONSULTAS DE MATERIALES ***