Informix 4gl español2

Por : Ing. Juan Carlos Contreras Villegas

(c) Derechos Reservados prohibida su reproducción total o parcial

sin el consentimiento del autor

VS

. Curso de Programación en INFORMIX-4GL

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

Página 1

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. Declaración de variables 4. Asignación de datos 5. Estructuras de control

5.1 Estructura Secuencial 5.2 Estructura Alternativa 5.3 Estructura Repetitiva

6. Manejo de Menúes 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 Especificación del criterio de búsqueda 9.2 Preparación de la consulta 9.3 Manejo de cursores

10. Reportes simples 10.1 Construcción del reporte 10.2 Estructura del Formato de reporte 10.3 Sentencias que se utilizan en la función 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



Página 2

I INTRODUCCIÓN

1.1.- Introducción.- 4GL .- Four Generation Language (Lenguaje de programación de cuarta generación), es un lenguaje de programación que conjuntamente con el SQL permiten crear sistemas de archivos. INFORMIX-4GL es un lenguaje de cuarta generación 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 manipulación de los datos) • Estructuras de control (IF, WHILE, Etc) • Manejo de menús • Manejo de ventanas • Formatos de pantalla • Reportes

2.- Que es una Base de datos ? - Es una colección de información o datos relacionados. - Es un conjunto de archivos relacionados. - Es una colección de tablas. 3.- Que es una tabla ? Una tabla es una colección de datos organizados en filas y columnas

Una base de datos contiene al menos una tabla, como también 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.



Página 3

El ejemplo planteado para el presente curso es un sistema de control de almacén para la empresa DELTA. El diseño de la base de datos ALMACEN es la siguiente:

MATERIAL

SECCION

PROVEEDOR

cod_matdescrip

p_unit

stock_mincantidad

Recibe

cant

nro_egr

p_unit

fechacod_sec descrip

Tiene

cod_pro nombre

cantp_unitnro_ing

Base de datos ALMACEN

INGRESO

EGRESO

Contiene

Hace

fecha 1

M

N

N

1 N

M

N

direc



Página 4

Descripción de las tablas para la base de datos ALMACEN

PROVEEDOR

cod_prov nombre

MATERIALcod_mat descrip p_unit stock_min cantidad

SECCION

cod_sec descrip

INGRESOS

EGRESOS

nro_egr

fechanro_ing

fecha

cod_prov

MAT_ING

MAT_EGR

nro_ing p_unitcantcod_mat

nro_egr p_unitcantcod_mat

cod_sec

direc



Página 5

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



Página 6

En un programa 4GL existen 5 secciones, las cuales se detallan a continuación: Sección DATABASE.- En esta sección se especifica el nombre de la base de datos con la que se va a trabajar. Sección GLOBALS.- En esta sección se definen las variables que serán globales a todo el programa. Sección MAIN .- En esta sección se escriben la instrucciones. Sección FUNCTION.- Se pueden definir las funciones o procedimientos que seran necesarios para el programa. Sección REPORT.- También 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 línea. Una sentencia 4GL termina cuando comienza otra sentencia. El sistema a desarrollar se llamara SCA (Sistema de control de almacén) y estará compuesto por los siguientes módulos

sca_main

sca_mate sca_prove sca_secc sca_ingr sca_egre sca_repo

modulosprograma Un programa en 4GL esta compuesto por módulos, de los cuales solo uno de ellos debe tener la palabra reservada MAIN y sera considerado módulo principal.



Página 7

El diseño de pantalla para el sistema será el siguiente:

Menu: Proveedores seCcion Ingresos Egresos Reportes SalirMateriales

ABC de materiales---------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------

S I S T E M A

D E C O N T R O L

D E A L M A C E N

Linea de MenuLinea de

Comentarios

Formatosde

pantalla

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) dígitos significativos, y n (n<=m) dígitos a la derecha de la coma decimal. Cuando se le da ambos parámetros (m y n) la variable tiene aritmética de punto fijo. MONEY(m,n).- Su comportamiento es similar al tipo de dato DECIMAL. si no tiene ningún parámetro es interpretado como un DECIMAL(16,2), si solo tiene el parámetro 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 precisión 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 precisión 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.



Página 8

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.*



Página 9

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 línea 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



Página 10

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



Página 11

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 opción por default sea la indicada por "nombre opcion" La cláusula KEY en Command permite que la opción sea seleccionable por la tecla indicada. Por default las opciones pueden ser seleccionables por la primer letra de dicha opción. Si dos opciones comienzan con la misma letra se utiliza la cláusula KEY para definir otra letra y romper la ambigüedad.



Página 12

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() DISPLAY FORM form_main COMMAND key(C) "seCcion" "Mantenimiento de seccion" CALL p_seccion() DISPLAY FORM form_main COMMAND "Proveedores" "Mantenimiento de proveedores" CALL p_proveedor() DISPLAY FORM form_main COMMAND "Ingresos" "Registrar ingreso de materiales" CALL p_ingreso() DISPLAY FORM form_main COMMAND "Egresos" "Registrar egreso de materiales" CALL p_egreso() DISPLAY FORM form_main COMMAND "Reportes" "Emitir reportes de la base de datos" DISPLAY FORM form_main COMMAND "Salir" "Salir del sistema de control de almacen" EXIT MENU END MENU CLOSE FORM f_main

END MAIN



Página 13

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 manipulación 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 extensión .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 extensión .FRM



Página 14

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 sección DATABASE permite especificar la base de datos con la que se va a

trabajar. • La sección SCREEN permite definir todo lo que se vera en la pantalla. También

permite definir las variables y los campos de pantalla. • La sección TABLES permite especificar las tablas con las que se interactuara en esta

pantalla.



Página 15

• La sección ATTRIBUTES permite asociar las variables de pantalla a un tipo de dato para su validación, también permite dar o definir algunos atributos a los campos de la pantalla.

• La sección INSTRUCTIONS permite definir la forma de los delimitadores, por default son dos parentesis, pero se puede cambiar por dos caracteres. En esta sección también 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 automáticamente 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 condición.

Los colores pueden ser: WHITE YELLOW MAGENTA RED CYAN GREEN BLUE BLACK BLINK REVERSE • COMMENTS = "Comentario" .- Permite desplegar el comentario en la línea 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 minúsculas sin

importar el estado del teclado.



Página 16

• INCLUDE = ( val1, val2, ... ) .- Permite definir una lista de valores que serán 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 edición de

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

muy utilizado para campos de tipo numérico. se pueden usar los siguientes caractes para formato: A Permite la entrada de un caracter alfabético # Permite el ingreso de un dígito X Permite el ingreso de cualquier caracter. • REQUIRED .- Obliga a que sea ingresado algun valor para el campo. Si no se

ingresa ningún valor, INFORMIX hará que el cursor no pueda moverse a ningún 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 mayúsculas 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 continuación mostraremos los formatos de pantalla para la pantalla de presentación inicial, y el formato de pantalla para materiales.



Página 17

# Formato de pantalla para la pantalla de presentación del sistema de control de almacén # NOMBRE : f_main.per # Designed by : Juan Carlos Contreras Villegas DATABASE formonly SCREEN { ------------------------------------------------------------------------------- S I S T E M A D E C O N T R O L D E A L M A C E N [x] ------------------------------------------------------------------------------- } ATTRIBUTES x=formonly.nada; INSTRUCTIONS DELIMITERS " "



Página 18

#**** Formato de pantalla para el modulo de materiales #**** Nombre : f_mate.per #**** CopyRight (1995) by Juan Carlos Contreras Villegas DATABASE almacen SCREEN { ------------------------------------------------------------------------------- M A T E R I A L E S ===================== 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 " "



Página 19

3.7.2.- Instrucciones para manejo de formatos de pantalla. desde 4GL.-

• OPEN FORM var_formato FROM "archivo_formato" Esta instrucción 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



Página 20

{****** 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



Página 21

3.8.- CAPTURA DE DATOS.- La sentencia INPUT permite la captura de datos desde pantalla a través 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 cláusula 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.



Página 22

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 cláusula transfiere el control del programa a las sentencias especificadas cuando el el usuario a terminado la introducción de datos. ON KEY (tecla) .- Transfiere el control del programa a las sentencias especificadas cuando el usuario pulse la tecla especificada. También 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 función 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.



Página 23

Ejemplo: Como ejemplo realizaremos los procedimientos de Altas, Bajas y modificación 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) IF reg.cod_mat IS NOT NULL THEN 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



Página 24

#*************** PERMITE DAR DE BAJA MATERIALES **************** FUNCTION baja_mate() DEFINE reg RECORD LIKE material.*, codi LIKE material.cod_mat INITIALIZE reg.* TO NULL 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



Página 25

#********** PERMITE MODIFICAR DATOS DE MATERIALES **************** FUNCTION modi_mate() DEFINE reg RECORD LIKE material.* INITIALIZE reg.* TO NULL MESSAGE " ESC = Salir CTRL-G = Grabar" ATTRIBUTE (REVERSE) INPUT BY NAME reg.* WITHOUT DEFAULTS AFTER FIELD cod_mat IF reg.cod_mat IS NOT NULL THEN SELECT * INTO reg.* FROM material WHERE cod_mat=reg.cod_mat IF STATUS=NOTFOUND THEN ERROR "CODIGO NO ENCONTRADO" NEXT FIELD cod_mat ELSE DISPLAY BY NAME reg.* END IF END IF ON KEY (control-g) IF reg.cod_mat IS NOT NULL THEN UPDATE material SET *=(reg.*) WHERE cod_mat=reg.cod_mat ERROR "REGISTRO ACTUALIZADO" INITIALIZE reg.* TO NULL CLEAR FORM NEXT FIELD cod_mat END IF END INPUT

END FUNCTION



Página 26

3.9.- QUERY BY EXAMPLE.- El Query By Example (Consulta por ejemplos) Es una forma de escribir programas que permiten recuperar información basado en un criterio de búsqueda 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 búsqueda) - PREPARE (Como se prepara una sentencia SELECT ejecutable ) - Manejo de cursores - DISPLAY (como mostrar información 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 búsqueda es CONSTRUCT. La sentencia CONSTRUCT permite crear una variable CHAR (string) que contiene la condición para la cláusula 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 búsqueda.



Página 27

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 después 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.



Página 28

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 Posiciona el puntero del cursor en el ultimo registro y recupera sus datos en las variables especificadas en la lista de variables FETCH PREVIOUS 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. CLOSE NombreCursor Cierra el cursor (destruye el archivo temporal).



Página 29

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.



Página 30

#***** 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 DISPLAY BY NAME reg.* MENU "VER" COMMAND "Primero" "Ver el primer registro de la consulta" FETCH FIRST q_mat INTO reg.* DISPLAY BY NAME reg.* COMMAND KEY (R) "pRoximo" "Ver Siguiente registro de la consulta" FETCH NEXT q_mat INTO reg.* IF STATUS=NOTFOUND THEN ERROR "No hay mas registros hacia adelante" ELSE DISPLAY BY NAME reg.* END IF COMMAND "Anterior" "Ver anterior registro de la consulta" FETCH PREVIOUS q_mat INTO reg.* IF STATUS=NOTFOUND THEN ERROR "No hay mas registros hacia atras" ELSE DISPLAY BY NAME reg.* END IF COMMAND "Ultimo" "Ver el ultimo registro de la consulta" FETCH LAST q_mat INTO reg.* DISPLAY BY NAME 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



Página 31

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 información 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



Página 32

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 líneas) (Default=3 líneas) BOTTOM MARGIN n # margen inferior ( en líneas ) (Default=3 líneas) PAGE LENGTH n # Longitud de pagina (en líneas) (Default=66 líneas) 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 # Subtítulos ( Antes que se ejecute ON EVERY Sentencia # ROW) ---- AFTER GROUP OF variable # Sub pie de pagina (después que se haya ejecutado Sentencia # ON EVERY ROW) ---- ON LAST ROW # Especifica lo que Informix hará después que se haya Sentencia # procesado la última línea que recibió REPORT ---- END REPORT



Página 33

Donde n es un numero literal, es decir, n no puede ser una variable

Margen superior ->

Margen inferior ->

Logitud de pagina

RIGHT MARGIN(Ancho de pagina en caracters)

Titulo o encabezado de cada paginaPAGE HEADER

----------------------------------------------

----------------------------------------------Pie de paginaPAGE TRAILER

Subtitulo: BEFORE GROUP OF

Subpie de pagina: AFTER GROUP OF

Lineas de detalle : ON EVERY ROW----------------------------------

Subtitulo: BEFORE GROUP OF

Lineas de detalle : ON EVERY ROW----------------------------------

Subpie de pagina: AFTER GROUP OF

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 "###"



Página 34

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 condición dentro de un grupo. GROUP SUM (expresion) [ WHERE Condicion ] #suma la expresión en el grupo GROUP AVG (expresion) [ WHERE Condicion ] # calcula el promedio del grupo GROUP MIN (expresion) [ WHERE Condicion ] #calcula el menor de la expresión GROUP MAX (expresion) [ WHERE Condicion ] #calcula el mayor de la expresión Las funciones GROUP se utilizan normalmente en la sección 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



Página 35

#***** 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



Página 36

#************** 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



Página 37

#************** 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 línea PRINT "---------------------------------------------------------", "---------------------" PRINT COLUMN 50,"TOTAL --> ",SUM(reg.cant*reg.p_unit) END REPORT



Página 38

3.11.- MANEJO DE ARREGLOS CON FORMATOS DE PANTALLA.-

Ingresos : Anular Consultar SalirIngresar

Permite realizar las notas de ingreso de materiales---------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------

DESCRIPCION PRECIO UNIT.CANTIDAD

Nro.IngresoFecha :

ProveedorCODIGO MONTO

TOTAL - >

INGRESOSDE MATERIALES

---------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------

Hospital JaponesSeccion Almacen

Para poder trabajar con datos que están en múltiples 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.



Página 39

#****** 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 )



Página 40

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 Sentencias # Estas sentencias se ejecutaran cuando -------------- # el cursor esta saliendo de una fila -------------- ON KEY (tecla) Sentencias # Estas sentencias se ejecutaran cuando -------------- # se pulse la tecla especificada -------------- END INPUT



Página 41

• 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() .- Función que devuelve la posición de fila en la que se encuentra el cursor en el arreglo de pantalla. ARR_CURR() .- Función que devuelve la posición de fila en la que se encuentra el cursor en el arreglo de programa. ARR_COUNT() .- Función 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 : Anular Consultar SalirIngresar

Permite realizar las notas de ingreso de materiales---------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------

DESCRIPCION PRECIO UNIT.CANTIDAD

Nro.IngresoFecha :

ProveedorCODIGO MONTO

TOTAL - >

INGRESOSDE MATERIALES

---------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------

Hospital JaponesSeccion Almacen

100200300

D

E

F



Página 42

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)



Página 43

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



Página 44

FUNCTION PedirEncabezado(regi) DEFINE salir SMALLINT, regi RECORD nro_ing INTEGER, fecha DATE, cod_prov LIKE proveedor.cod_prov, nombre LIKE proveedor.nombre 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 IF STATUS=NOTFOUND THEN 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



Página 45

FUNCTION PedirDetalle(regi) DEFINE salir SMALLINT, regi RECORD nro_ing INTEGER, fecha DATE, cod_prov LIKE proveedor.cod_prov, nombre LIKE proveedor.nombre 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



Página 46

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,



Página 47

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 INITIALIZE regi.* TO NULL EXIT INPUT ELSE ERROR "No hay Items validos. el INGRESO no fue registrado" END IF END INPUT RETURN regi.*, salir END FUNCTION



Página 48

{*** 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 INITIALIZE regi.* TO NULL 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 IF STATUS=NOTFOUND THEN INITIALIZE regi.* TO NULL 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



Página 49

{*** PROCESO QUE MUESTRA LOS ITEMS DE LA NOTA DE INGRESO ***} FUNCTION mostrarDetalle(regi) DEFINE regi RECORD nro_ing INTEGER, fecha DATE, cod_prov LIKE proveedor.cod_prov, nombre LIKE proveedor.nombre, anulado CHAR(1) 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,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



Página 50

{*** PROCESO QUE PERMITE IMPRIMIR LA NOTA DE INGRESO ***} FUNCTION print_ing(regi) DEFINE regi RECORD nro_ing INTEGER, fecha DATE, cod_prov LIKE proveedor.cod_prov, nombre LIKE proveedor.nombre, anulado CHAR(1) END RECORD, regd 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 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



Página 51

{*** PROCESO QUE FORMATO A LA NOTA DE INGRESO IMPRESA ***} REPORT nota_ing(regi,regd) DEFINE regi RECORD nro_ing INTEGER, fecha DATE, cod_prov LIKE proveedor.cod_prov, nombre LIKE proveedor.nombre, anulado CHAR(1) END RECORD, regd 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 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

Documents

Informix 4gl español2