Ruptura de Control en la Programación Estructurada

 

Los desarrolladores más ortodoxos se aferran vehementemente al uso estricto de Estructuras  de Control para asegurarse de que los desarrollos sean realizados cumpliendo las normas de la programación Estructurada. Estos desarrolladores vivieron una época muy ardua en la que mantener un programa al día y realizarle cambios continuos, en una programación carente de estructura era un verdadero tormento. Había programas que requerían más de 150 páginas de desarrollo. Las compilaciones podían llegar a las 350 páginas y el seguimiento del código fuente en cuanto a la lógica empleada era tan complicado como descifrar un mensaje de las tropas enemigas en plena guerra.

Hay gente que no pueden escuchar la palabra: GOTO porque enseguida sacan la estaca y la cruz para liberarse de tan horrendo maleficio.

En la época de la programación no estructurada, el uso del GOTO procuraba cubrir la ausencia de estructuras de control que hicieran posible generar operaciones cíclicas y repetitivas en la lógica del programa. Aparecieron, afortunadamente, las siguientes sentencias:

Dow: Do while  (ejecute mientras se cumpla la  condición)

Dou: repeat  (ejecute hasta que se cumpla la condición)

For: (con los valores de iteración desde … hasta ejecute)

El select los if anidados y el Case se convirtieron en grandes aliados del programador que le permitieron desarrollar códigos más entendibles para sus colegas y para ellos mismos a lo largo del tiempo.

Para pesar de algunos,  los siguientes códigos de operación han logrado “colarse” y romper el esquema rígido que tanto alivio ocasiona a muchos desarrolladores, provocando reacciones encontradas de amor-odio entre las viejas y nuevas tendencias de programación.

                    Iter, Leave, Leavesr, GOTO

 

La idea de este artículo no es provocar una discusión infinita entre los desarrolladores sino ilustrar el uso beneficioso que puede darse a sentencias que pueden verse como peligrosas pero que no lo son tanto. 

Algunos códigos fuentes simples y útiles en RPGLE-FREE

 

 

 

 

 

 

 

Algunos códigos fuentes simples y  útiles en RPGLE-FREE

Para ejecutar comandos:

En la hoja D, declaramos:

d clpstm          s            300

d@runsyscmd       pr                  extpgm('QCMDEXC')

d cmd                          200a   options(*varsize) const

d cmdlen                        15p 5 const

Monitoreamos la sentencia para que el programa no falle estrepitosamente en caso de que haya un error de ejecución del comando.

En este ejemplo estamos haciendo un chkobj de un objeto. Si el objeto no existe, el error que arroja el sistema operativo es CPF9801 con La sentencia monitor y la operación  on-error, enviamos el mensaje al usuario sin que el programa deje de estar operativo.

monitor;

        clpstm = 'chkobj obj(' + %trim(libreria) +

                 '/' +  %trim(archivo) +

                ') objtype(*file)';

                @runsyscmd(clpstm : %size(clpstm));

                on-error;

                  Dsp_error = 'Archivo solicitado no existe';

    endmon;

Simplificando la Validando de Fechas

En la hoja D:

d  Wrk_Fecha        s               D   datfmt(*eur)

En el Ejemplo trabajamos la fecha en formato *EUR (DD.MM.AAAA), por lo que a nivel de programación esperamos que el usuario haya colocado la fecha en  formato *Eur o que la fecha venga de un archivo generado con ese formato. Sin embargo, cabe destacar que este ejemplo es aplicable a cualquier formato con el que se desee trabajar.

Detectamos que la fecha es inválida pero no especificamos la razón (si es por el día, el mes o el año) cada programador puede refinar el código si así lo desea.

monitor;                               

  Wrk_fecha = %date(Fecha:*EUR);       

  on-error;                             

  dsp_error = 'Fecha  Inválida';

Endmon;

SQL Embebido - Sentencia USING y algo mas...

 

 

          SQL EMBEBIDO

          Sentencia USING

Cuando hacemos SQL dinámicos  requerimos construir dinámicamente la instrucción SELECT para extraer los registros que necesitamos de la base de datos. Muchas veces  las condiciones de selección son cambiantes  porque los valores de búsqueda son distintos dependiendo del proceso. En el programa, utilizamos variables  que contienen el valor de búsqueda de uno o varios campos dentro de las tablas de datos.  Las variables en el algoritmo de programación van teniendo valores  cambiantes y no es posible  colocar en Hard Code (código duro)  la sentencia SELECT del SQL. La sentencia “USING” permite solucionar este inconveniente.

 

Supongamos que tenemos que generar un reporte de inventario para varias filiales de una corporación. Tenemos en la base de datos una tabla de empresas filiales:

01= filia1  02= filial2  03 = filial3

En RPG FREE

1.-Declaramos las variables de trabajo para construir la sentencia dinámica

D Varsql1         s           1000a    Inz(*Blanks)

D V_Sql1          s           1000a

2.-Construimos la sentencia dinámica.

 (Como no sabemos la compañía que hay listar  colocamos = ?

exec sql set :V_SQL1 =       

  'select *    '||           

  'from INVENTARIO   '||         

  'Where CIA = ? '    ||  

  'order by CIA';        

3.-Ejecutamos el PREPARE

exec sql Prepare varsql1 From :v_sql1;

4.-Declaramos el Cursor.

exec  sql Declare c1 dynamic Scroll Cursor for varsql1

5.-Ejecutamos el OPEN del Cursor

 exec sql open c1 using :Var_CIA;

En este punto, se entiende que serán procesados aquellos registros de la base de datos

Cuyo valor en el campo compañía sea igual al valor del contenido de la variable: Var_CIA

 

6.- Ejecutamos el Fetch que sea requerido

exec sql fetch next from c1 into :Filler

 

                                          

 

Un caso menos obvio en su programación es el %LIKE% para armar la sentencia SQL. (Like = que contenga algo parecido a este texto)

Para utilizar el %LIKE%  es necesario primero construir el contenido de la variable que será aplicada en el USING en forma adecuada. Es decir en este caso la variable:  Var_Cía no debería contiene un valor numérico o alfabético sino que es el resultado de la concatenación de varios elementos que hacen posible para el SQL interpretar lo que se está pidiendo procesar.

Por ejemplo, supongamos que queremos buscar una dirección que tenga la palabra MADRID. En este caso requerimos el uso del LIKE de la siguiente manera:

Utilizamos una variable que llamaremos CIUDAD bien sea que el usuario la introduzca por pantalla o que la manipulemos en el programa.

CIUDAD = MADRID

Vamos a denominar a la variable colocada en la sentencia USING como: QRY_CIUDAD

Hacemos lo siguiente:

QRY_CIUDAD = ‘%’ + %trim(CIUDAD) + ‘%’

La sentencia SQl la podemos construir normalmente:

exec sql set :V_SQL1 =

                    'select ESTADO, CIUDAD, Descri '||

                    'from libsuarez/ciudades '||

                    'Where ciudad like  ? '    ||

                    'order by ciudad';

Cuando abrimos el cursor podemos colocar

exec sql open c1 using :QRY_CIUDAD;

 

 

Si te pareció interesante, reenvíalo a un amigo haciendo click en el sobrecito que está al final del artículo. El conocimiento es valioso, compártelo.


Autor: Ing. Liliana Suárez