Generaciones de lenguajes de programación
 
Los lenguajes de programación se dividen en 2 categorías fundamentales:
 
Bajo nivel: Son dependientes de la máquina, están diseñados para ejecutarse en una determinada computadora. A esta categoría pertenecen las 2 primeras generaciones.
 
Alto Nivel: Son independientes de la máquina y se pueden utilizar en una variedad de computadoras. Pertenecen a esta categoría la tercera y la cuarta generación. Los lenguajes de más alto nivel no ofrecen necesariamente mayores capacidades de programación, pero si ofrecen una interacción programador/computadora más avanzada. Cuanto más alto es el nivel del lenguaje, más sencillo es comprenderlo y utilizarlo.
 
Cada generación de lenguajes es más fácil de usar y más parecida a un lenguaje natural que su predecesores. Los lenguajes posteriores a la cuarta generación se conocen como lenguajes de muy alto nivel. Son lenguajes de muy alto nivel los generadores de aplicaciones y los naturales.
 
En cada nuevo nivel se requieren menos instrucciones para indicar a la computadora que efectúe una tarea particular. Pero los lenguajes de alto nivel son sólo una ayuda para el programador. Un mayor nivel significa que son necesarios menos comandos, debido a que cada comando o mandato de alto nivel reemplaza muchas instrucciones de nivel inferior.
 
Primera - Lenguaje de máquina: Empieza en los años 1940-1950. Consistía en sucesiones de dígitos binarios. Todas las instrucciones y mandatos se escribían valiéndose de cadenas de estos dígitos. Aún en la actualidad, es el único lenguaje interno que entiende la computadora; los programas se escriben en lenguajes de mayor nivel y se traducen a lenguaje de máquina.
 
Segunda - Lenguajes ensambladores: Fines de los '50. Se diferencian de los lenguajes de máquina en que en lugar de usar códigos binarios, las instrucciones se representan con símbolos fáciles de reconocer, conocidos como mnemotécnicos,. Aún se utilizan estos lenguajes cuando interesa un nivel máximo de eficiencia en la ejecución o cuando se requieren manipulaciones intrincadas. Al igual que los lenguajes de la máquina, los lenguajes ensambladores son únicos para una computadora particular. Esta dependencia de la computadora los hace ser lenguajes de bajo nivel.
 
Tercera: años '60. Los lenguajes de esta generación se dividen en tres categorías, según se orienten a: procedimientos: Requieren que la codificación de las instrucciones se haga en la secuencia en que se deben ejecutar para solucionar el problema. A su vez se clasifican en científicos (p.ej.: FORTRAN), empresariales (v.g.: COBOL), y de uso general o múltiple (p.ej.: BASIC). Todos estos lenguajes permiten señalar cómo se debe efectuar una tarea a un nivel mayor que en los lenguajes ensambladores. Hacen énfasis los procedimientos o las matemáticas implícitas, es decir en lo que se hace (la acción).
Problemas: Están diseñados para resolver un conjunto particular de problemas y no requieren el detalle de la programación que los lenguajes orientados a procedimientos. Hacen hincapié en la entrada y la salida deseadas.
Objetos: El énfasis se hace en el objeto de la acción. Los beneficios que aportan estos lenguajes incluyen una mayor productividad del programador y claridad de la lógica, además de ofrecer la flexibilidad necesaria para manejar problemas abstractos de programación.
 
Cuarta: su característica distintiva es el énfasis en especificar qué es lo que se debe hacer, en vez de cómo ejecutar una tarea. Las especificaciones de los programas se desarrollan a un más alto nivel que en los lenguajes de la generación anterior. La característica distintiva es ajena a los procedimientos, el programador no tiene que especificar cada paso para terminar una tarea o procesamiento. Las características generales de los lenguajes de cuarta generación son:
 
Uso de frases y oraciones parecidas al inglés para emitir instrucciones; no operan por procedimientos, por lo que permiten a los usuarios centrarse en lo que hay que hacer no en cómo hacerlo; Al hacerse cargo de muchos de los detalles de cómo hacer las cosas, incrementan la productividad.
 
Hay dos tipos de lenguajes de cuarta generación, según se orienten:
 
A la producción: Diseñados sobre todo para profesionales en la computación.
al usuario: Diseñados sobre todo para los usuarios finales, que pueden escribir programas para hacer consultas en una base de datos y para crear sistemas de información. También se llama lenguaje de consultas (SQL, Structured Query Language: lenguaje estructurado para consultas).
 
Lenguajes de cuarta generación
 
Fourth Generation Language. Los lenguajes de cuarta generación suponen una evolución de los de tercera generación. En estos lenguajes de programación avanzados, el programador no incorpora el procedimiento a seguir, ya que el propio lenguaje es capaz de indicar al ordenador cómo debe ejecutar el programa, Los lenguajes de cuarta generación son más fáciles de usar que los 3GL: suelen incluir interfaces gráficos y capacidades de gestión avanzadas, pero consumen muchos más recursos del ordenador que la generación de lenguajes previa.
 

No existe consenso sobre lo que es un lenguaje de cuarta generación (4GL). Lo que en un lenguaje de tercera generación (3GL) como COBOL requiere cientos de líneas de código, tan solo necesita diez o veinte líneas en un 4GL. Comparado con un 3GL, que es procedural, un 4GL es un lenguaje no procedural: el usuario define qué se debe hacer, no cómo debe hacerse. Los 4GL se apoyan en unas herramientas de mucho más alto nivel denominadas herramientas de cuarta generación. El usuario no debe definir los pasos a seguir en un programa para realizar una determinada tarea, tan sólo debe definir una serie de parámetros que estas herramientas utilizarán para generar un programa de aplicación. Se dice que los 4GL pueden mejorar la productividad de los programadores en un factor de 10, aunque se limita el tipo de problemas que pueden resolver. Los 4GL abarcan:

  • Lenguajes de presentación, como lenguajes de consultas y generadores de informes.
  • Lenguajes especializados, como hojas de cálculo y lenguajes de bases de datos.
  • Generadores de aplicaciones que definen, insertan, actualizan y obtienen datos de la base de datos.
  • Lenguajes de muy alto nivel que se utilizan para generar el código de la aplicación.
 
Los lenguajes SQL y QBE son ejemplos de 4GL. Hay otros tipos de 4GL:
 
Un generador de formularios es una herramienta interactiva que permite crear rápidamente formularios de pantalla para introducir o visualizar datos. Los generadores de formularios permiten que el usuario defina el aspecto de la pantalla, qué información se debe visualizar y en qué lugar de la pantalla debe visualizarse. Algunos generadores de formularios permiten la creación de atributos derivados utilizando operadores aritméticos y también permiten especificar controles para la validación de los datos de entrada.
 
Un generador de informes es una herramienta para crear informes a partir de los datos almacenados en la base de datos. Se parece a un lenguaje de consultas en que permite al usuario hacer preguntas sobre la base de datos y obtener información de ella para un informe. Sin embargo, en el generador de informes se tiene un mayor control sobre el aspecto de la salida. Se puede dejar que el generador determine automáticamente el aspecto de la salida o se puede diseñar ésta para que tenga el aspecto que desee el usuario final.
 
Un generador de gráficos es una herramienta para obtener datos de la base de datos y visualizarlos en un gráfico mostrando tendencias y relaciones entre datos. Normalmente se pueden diseñar distintos tipos de gráficos: barras, líneas, etc.
 
Un generador de aplicaciones es una herramienta para crear programas que hagan de interface entre el usuario y la base de datos. El uso de un generador de aplicaciones puede reducir el tiempo que se necesita para diseñar un programa de aplicación. Los generadores de aplicaciones constan de procedimientos que realizan las funciones fundamentales que se utilizan en la mayoría de los programas. Estos procedimientos están escritos en un lenguaje de programación de alto nivel y forman una librería de funciones entre las que escoger. El usuario especifica qué debe hacer el programa y el generador de aplicaciones es quien determina cómo realizar la tarea.
 
Técnicas de 4ª generación
 
La herramienta más ampliamente identificada como de 4ª generación la constituyen los lenguajes de 4ª generación (4GL) o lenguajes no procedurales. Los 4GL frecuentemente son referenciados como "herramientas de prototipado". De la misma forma, el término de prototipado se referencia como desarrollo de software utilizando 4GL.
 
La 4ª generación está constituida principalmente por:
  • Generadores de programas o sistemas que traducen especificaciones a lenguajes de 3ª generación.
  • Lenguajes no procedurales.
 
Los lenguajes no procedurales surgen como resultado de la frustración de los usuarios ante la incapacidad de poder construir sus propios sistemas o aplicaciones a pesar del desarrollo del software.
 
Los desarrolladores de software, ante este movimiento de "desarrollo para usuarios finales" (end-users), se dieron cuenta de que lo que hacía falta eran lenguajes de más alto nivel que permitieran el desarrollo de programas en mucho menos tiempo.
 
Como consecuencia de esto, los generadores y la programación no procedural, así como los lenguajes de interrogación de bases de datos (SQL), se hicieron populares entre usuarios finales. También aparecieron las técnicas de prototipado y lo que vamos a llamar "desarrollo evolutivo" o evolucionado.
 
La idea subyacente era que ya que la programación se iba a hacer mucho más rápidamente, se podría obviar la etapa de diseño y corregir los errores que se podrían producir por ello en menos tiempo que realizar la primera fase de diseño.
 
Lenguajes de 4ª generación (4GL):
 
Son lenguajes de más alto nivel, los cuales proporcionan al programador (en este caso podrá ser el usuario final), la posibilidad de ejecutar funciones complejas utilizando sólo unos pocos comandos (reducimos un poco la sintáxis).
 
Básicamente son lenguajes de 3ª generación que han sido enriquecidos y a los que se les ha añadido su propia base de datos.
 
En muchas ocasiones, el conjunto de comandos es bastante reducido, por lo que se reduce el tiempo de aprendizaje por parte del programador.Además, suelen incorporar sus propios editores "dirigidos por la sintásix", que no son más que sistemas de desarrollo interactivos que permiten la edición de comandos antes de que éstos sean procesados.
 
Ventajas de su uso:
 
Proporcionar flexibilidad, facilidad de uso y velocidad (reducen el tiempo de propagación)
 
Son fáciles de aprender
 
El conjunto de instrucciones es mucho más reducido que en los lenguajes tradicionales.
 
El nivel de los programadores se reduce, y hace que todos los desarrolladores de software produzcan más.
 
Inconvenientes:
 
Se necesitan altos recursos (requerimientos) de la máquina.
 
Normalmente, todos los 4GL llevan incorporado su propia base de datos, con lo cual, aparece el problema de incompatibilidad entre distintas bases de datos.
 
La mayor parte de las aplicaciones con 4GL deben trabajar con su base de datos o con otras; en este último caso tienen que leer la información de la base de datos, deberán traducirla a su propio 4GL y luego invertir el proceso para actualizar la base de datos que han leido. Así pueden aparecer problemas de integridad en la base de datos.
 
Las aplicaciones creadas por estos lenguajes suelen ser difíciles de mantener.
 
Las aplicaciones suelen ser lentas en su ejecución.
 
Tienen una funcionalidad limitada porque los lenguajes, cuanto más abstractos sean o tengan un mayor nivel, la capacidad para manipular internamente los recursos de la máquina se pierde.
 
Componentes y funcionalidades de un 4GL
 
Los principales componentes de un lenguaje de cuarta generación son:
 
Editor
 

Donde se escriben las sentencias del lenguaje de programación. Puede contar con:

  • Ayuda de tratamiento de textos.
  • Facilidades para incorporar el nombre de variables, objetos o funciones.
  • Chequeo preliminar de errores de sintaxis.
  • Utilidades de selección, copia o movimiento de bloques.
  • Posibilidad de deshacer el último cambio.
Compilador
 

Traduce las sentencias del lenguaje fuente a código binario o a un lenguaje intermedio. Las características más importantes de un compilador son:

  • Posibilidad de separar la interpretación del código fuente de la generación del código. Esto permite la ejecución inmediata de una parte del código sin haber generado el fichero ejecutable.
  • Gestión avanzada de errores. Recuperación desde un estado erróneo del código para poder continuar con el proceso de interpretación y así detectar el mayor número posible de errores en una única compilación.
  • Optimización del código. La traducción del código fuente va acompañada por una optimización del código (en tamaño y/o en rendimiento) a la hora de ejecutar la aplicación.
  • Algunos lenguajes incorporan también la posibilidad de utilizar y generar librerías de enlace dinámico (DDL), lo que permite una mayor flexibilidad y capacidad de reutilización del código.
Módulo de acceso a base de datos
 
Incorpora la interfaz con el gestor de base de datos. Facilita toda la comunicación con la base de datos, desde el diseño de las tablas hasta la construcción de sentencias para recuperar información. La mayoría de los 4GLs soporta el lenguaje SQL estándar como lenguaje de acceso a base de datos relacionales, lo que garantiza la portabilidad.
 
Módulo de ayuda a las pruebas
 
Hay 4GLs que permiten una ejecución controlada del código para poder aislar un error, con técnicas de ejecución paso a paso, localizando los puntos de parada y permitiendo la modificación del contenido de las variables durante la ejecución.
 
Generador de informes y pantallas
 
Los 4GLs incorporan módulos para la construcción rápida de pantallas, ya sea en modo carácter o en modo gráfico. Asimismo, algunos cuentan con un módulo de generación de informes a través de consultas a la base de datos.
 
Diccionario
 
Algunos 4GLs cuentan con un diccionario en el que almacenan la información referente a los objetos de la aplicación. Esto facilita la gestión de los objetos generados especialmente para trabajos en grupo.
 
Gestor de librerías
 

El gestor de librerías permite:

  • La distribución de los objetos por las librerías siguiendo los criterios que se establezcan.
  • La localización rápida de los objetos con el fin de analizar el impacto de una modificación o corregir un error.
  • La coordinación de los trabajos en equipo.
Módulo de control de versiones
 
Algunos lenguajes de cuarta generación incorporan facilidades para el control de versiones o tienen interfaz con alguna herramienta del mercado para el control de versiones.
 
Biblioteca con funciones u objetos reutilizables en la aplicación
 
La funcionalidad de este tipo de bibliotecas se describe en detalle en el apartado de otras herramientas al hablar de bibliotecas de clases de objetos.
 
Ejemplos de Lenguajes 4GL
 
Algunos de estos lenguajes son: Visual Basic, INFORMIX 4GL, Visual J++, Visual C.
 
Ejemplos de programación 4GL
 
IBM INFORMIX-4GL permite formar un ambiente de producción y desarrollo de aplicaciones de cuarta generación que proporciona todo el poder y la flexibilidad necesarios para el desarrollo de aplicaciones. Su principal característica es ofrecer una productividad superior sin reducir la flexibilidad que necesitan las aplicaciones de producción aún más exigentes. En un solo ambiente se encuentran: reportes, formas, menús, pantallas, eliminando la necesidad de otros paquetes de desarrollo. Incluye IBM INFORMIX-4GL Rapid Development System (RDS), IBM INFORMIX-4GL Interactive Debugger e IBM INFORMIX-4GL Compiled. Juntos ellos forman un ambiente completo de desarrollo y producción para aplicaciones de cuarta generación que provee poder y flexibilidad a todas sus necesidades de desarrollo de aplicaciones.
 
Requerimientos de HW y SW:
 
IBM Informix Dynamic Server, Sistemas Operativos: UNIX, Espacio en Disco: 40 MB
 
PROGRAMACION INFORMIX-4GL
 
EJEMPLO 1 de programación:

  MAIN
    DEFINE answer CHAR(1)
    OPTIONS
  PROMPT LINE 22
MESSAGE LINE LAST
HELP KEY CONTROL-I
HELP FILE "menuhelp.ex"
MESSAGE "Type the first letter of the option you want "
  "or CTRL-I for instructions"
MENU "TOP LEVEL"
















END MENU		 COMMAND "Customer"
  "Go to the customer menu"
HELP 1
CALL cust_menu()
COMMAND "Orders"
  "Add a new order"
PROMT "Do you want to place an order "
  "for a customer ? (y/n)"
  FOR CHAR answer
IF answer='n' then CONTINUE MENU
CALL dummy()
. . . . . . . . . . . . . .
COMMAND KEY(!) CALL bang()
  NEW OPTION "customer"
   
  END MAIN
   
  FUNCTION dummy()
  ERROR "function not yet implemented"
SLEEP 3
CLEAR SCREEN
END FUNCTION
.. . . . . . . . . . .
 
PROGRAMACION INFORMIX-4GL
 
- Acceso a una fila segun condición:
Sintaxis SELECT:
 
  SELECT clausula
  [INTO clausula]
[FROM clausula]
[WHERE clausula]
[GROUP BY clausula]
[HAVING clausula]
[ORDER BY clausula]
[INTO TEMP clausula]
 
- EJEMPLO 2 de programación:

  DATABASE stores
  GLOBALS
  DEFINE p_customer RECORD LIKE customer.*
END GLOBALS
MAIN
  DEFINE p_count INTEGER
OPEN FORM f_cust FROM "custform"
DISPLAY FORM f_cust
PROMPT "Enter customer number:" FOR
p_customer.cnum
  SELECT * INTO p_customer FROM customer
    WHERE cnum = p_customer.cnum
  DISPLAY BY NAME p_customer
SELECT count(*) INTO p_count FROM customer
    WHERE orders.cnum = p_customer.cnum
  DISPLAY "Number of orders:", p_count AT 16,1
END MAIN
 
PROGRAMACION INFORMIX-4GL
 
- Acceso a un conjunto de filas segun condicion:
Sintaxis:

  DECLARE cursor -->
  OPEN cursor - - > + - - - - - - - - +
      |- - - - - - - - - -|
      |- - - - - - - - - -|
      + - - - - - - - - +
       
  FETCH cursor   +- - - - - - - - -+
    - - > |- - - - - - - - - -|
      |- - - - - - - - - -|
    - - > + - - - - - - - - +
    - - > NOT FOUND
  DECLARE cursor_name CURSOR FOR sql_statement
OPEN cursor_name [USING variable_list]
FETCH cursor_name [INTO variable_list]
CLOSE cursor_name
 
- EJEMPLO 3 de programación:

  DATABASE stores
  GLOBALS
    DEFINE p_customer RECORD LIKE customer.*
  END GLOBLAS
   
  MAIN
  DEFINE answer CHAR(1)
OPEN FORM f_cust FROM "custform"
DISPLAY FORM f_cust
DECLARE pointer1 CURSOR FOR
      SELECT * FROM customer ORDER BY
   
  lname
  OPEN pointer1
WHILE TRUE
  FETCH pointer1 INTO p_customer.*
IF STATUS = NOT FOUND
  THEN EXIT WHILE
  END IF
DISPLAY BY NAME p_customer.*
PROMPT "Type carriage RETURN to continue"
  FOR CHAR answer
   
END WHILE
CLOSE pointer1
CLEAR SCREEN
END MAIN
 
PROGRAMACION INFORMIX-4GL
 
- Alternativa en uso del FETCH: FOREACH
Sintaxis:

  FOREACH cursor_name [INTO program_variable]
    DISPLAY program_variable TO creen_record
  END FOREACH
 
- EJEMPLO 4 de programación:
  . . . . . . . . . . . . . . . . .
MAIN
  . . . . . . . . . . . . . . . . .
DECLARE pointer1 CURSOR FOR
    SELECT * FROM customer ORDER BY lname
  FOREACH pointer1 INTO p_customer.*
  DISPLAY BY NAME p_customer.*
  PROMPT "Type carriage RETURN to continue"
    FOR CHAR answer
END FOREACH
CLEAR SCREEN
END MAIN
 
- SCROLLing CURSORS (cursores direccionables)
Sintaxis:
  DECLARE cursor_name SCROLL CURSOR FOR sql_statement
  FETCH   NEXT | PREVIOUS | PRIOR | FIRST | LAST |
  RELATIVE m | ABSOLUTE m
cursor_name INTO variable_list
 
- EJEMPLO 5 de programación (se crea tabla temporal)

  FUNCTION find_init()
    DECLARE pointer1 SCROLL CURSOR FOR
      SELECT * FROM customer ORDER BY lname
    OPEN pointer1
  END FUNCTION
   
  FUNCTION first_cust()
    FETCH FIRST pointer1 INTO p_customer.*
CALL DISPLAY_CUST()
  END FUNCTION
 
PROGRAMACION INFORMIX-4GL
 

- Resolucion de consultas no previstas
(en estilo QBE: Query By Example)

  1. Construir condicion de busqueda:
    Sintaxis:

      CONSTRUCT variable ON column_list
        FROM form_field_list

  2. Crear setencia sql:
    Sintaxis:

      LET sql_statement_var="SELECT * FROM customer"
        "WHERE " where_clause CLIPPED
          |
          variable del CONSTRUCT

  3. Preparar sentencia para ejecucion (compilacion dinamica):
    Sintaxis:
      PREPARE exex_statement FROM sql_statement_var

  4. Declarar cursor si la ejecucion de la sentencia puede retornar mas de una fila
  5. Ejecutar instruccion
 
- EJEMPLO 6 de programación:

  FUNCTION find_cust()
  DEFINE where_clause CHAR(200)
DEFINE sql_statement CHAR(250)
CONSTRUCT BY NAME where_clause ON customer
   
  LET sql_statement="SELECT * FROM customer"
    "WHERE " where_clause
CLIPPED
  DISPLAY where_clause AT 18,1
DISPLAY sql_statement AT 19,1
   
  PREPARE exec_statement FROM
sql_statement
  DECLARE pointer1 CURSOR FOR
exex_statement
  . . . . . . . . . . . . . . . . .
  OPEN pointer1
FOREACH pointer1 INTO p_customer.*
    . . . . . . . . . . . . . . . .
DISPLAY BY NAME p_customer.*
  END FOREACH
. . . . . . . . . . . . . . . .
END FUNCTION
 
Bucle FOR EACH
 
La estructura de control FOR EACH sirve para moverse por los elementos de una estructura de datos, como podría ser un vector, y realizar acciones para cada una de los elementos.
 
Veamos con un ejemplo esta estructura de control: En el ejemplo primero creamos un vector y rellenamos con números cada una de sus casillas, con un bucle FOR normalito. Más tarde utilizamos el bucle FOR EACH para acceder a cada una de las posiciones de este vector de números y escribir en la página cada una de estos números.
 
dim tor(20)
for i=0 to 20
tor(i) = i
next
for each i in tor
document.write (tor(i))
next

 
Fijémonos en el segundo bucle, se indica que para cada i (i es el índice con el que podemos movernos en el bucle y en la estructura) dentro de tor (que es la estructura, en este caso un vector) haga un document.write(tor(i)). Con tor(i) accedemos a la casilla actual y document.write() sirve para escribir algo en la página web. Conbinadas lo que se escribe es lo que hay en la posición actual del vector.
 
Cursores
 
Estas sentencias permiten definir un conjunto de campos y registros, sobre los cuales se podrá. Modificar valores, Eliminar registros y moverse dentro de los registros que cumplan con las restricciones definidas para la sentencia.
 
La mayor ventaja es que la sentencia definida es conservada en una variable, de tipo cursor, esta puede ser utilizada dentro del rango definido al declararla (Global, Shared, Instance, Local)
 

Para trabajar con cursores se definenen 3 pasos:

  • Declarar el Cursor, esto se hace estando en un modulo ejecutable de programa o bien en alguna casillad de declaración de variables.
  • Abrir el Cursor, esta operación inicializa la sentencia SQL definida en el paso anterior.
  • Trabajar con el cursor, esto se refiere a las acciones de Navegar, Actualizar y Eliminar.
  • Cerrar el Cursor, esto libera la memoría que utiliza la variable declarada como cursor. Se puede volver a Abrir el Cursor, si fuese necesario
Es una buena politica comprobar el valor del sqlca.sqlcode, para ver si la operación realizada fue satisfactoria, al abrir, trabajar o cerrar el cursor.
 
Declarar el Cursor
 
Para declarar el cursor. Si esta en un modulo ejecutable de programa presione el boton y elija la opción 'Declare', si esta en alguna de las casillas de declaración de variables/constantes haga doble click sobre el icono que dice 'Cursor', en ambos casos se continua como sigue.
 
Aparecera la ventana "Selección de Tabla", solo las tablas que se seleccionen del lístado será posible de manipular. Presione el botón 'Open' para que aparescan las tablas seleccionadas, o presione el botón 'Cancel' para cancelar la operación. La opción 'System Tables' permite seleccionar las Tablas del catalogo de la Base de Datos; estas Tablas son utilizadas para la Administración de la Base de Datos.
 
Las Tablas seleccionadas aparecen en la ventana en una forma grafica y tambien las relaciones existentes.
 
Seleccione los campos, haciendo un click sobre ellos, en la representación grafica de la Tabla.
 
En la parte inferior de la ventana aparecen los topicos de trabajo, estos topicos se trabajan igual que cuando se selecciona el 'Origen de Datos' para un Datawindows.
 
Despues de definir la sentencia, cierre la ventana, al hacerlo se preguntara el nombre que tendra el cursor, presione el botón 'Ok', y la sentencia se pegara donde este el cursor en la ventana origen.
 
La sentencia es finalizada con un punto y coma (;), si esta utilizando un Objeto de Transacción distinto al estandar (sqlca), inmediatamente antes del punto y coma escriba lo siguiente:

  USING <otro obj>
Donde <otro obj>, corresponde a otro objeto de transacción definido en la aplicación.
 
Abrir el Cursor
 
Esta operación se realiza en un modulo de codigo ejecutable de program. Para abrir un cursor, la sentencia es la siguiente:

  USING <otro obj>
Donde <nombre cursor> es el nombre que se le asigno al cursor al momento de declararlo. Recuerde que solo puede utilizar los cursores que esten definidos(Globales, Shared, Instance, Local) para su utilización en el rango que abarque el modulo en uso.
 
Trabajar con el cursor
 
El trabajar con el cursor se refiere ha hacer uso de este para algún proceso. Es así como se puede obtener Datos de los registros que cumplan con las restricciones definidas al declarar el cursor. Tambien se pueden eliminar el registro donde este actualmente, de la lista de registros que cumplan con las restricciones definidas al declarar el cursor. Por último, tambien se puede actualizar del registro actual, el(los) campo(s) que forman parte de la declaración del cursor.
 
A continuación definiremos cada una de estas operaciones:
 
Obtener Datos
 
Para obtener los datos de un registro se utiliza la siguiente sentencia:
 
FETCH <operador naveg> <nombre cursor> INTO <lista variables> ;
 
Donde:
 
<nombre cursor> es el nombre del cursor de donde se desea obtener los datos. Si es la primera sentencia despues de haber abierto el cursor, se obtendran los datos de el primer registro que cumpla la condición fijada en la declaración del cursor, ya que el indicador de posición del registro actual esta en 0. Si se vuelve a repetir la misma sentencia se obtendra el segundo registro, y así consecutivamente.
 
<operador naveg> es una palabra reservada que se utiliza para indicar de donde, dentro de los registros que cumplan la declaración del cursor, se obtendrán los datos para llenar la <lista de variables>. Esta palabra reservada es optativa, ya que por defecto asume NEXT. Las palabras reservadas son las siguientes:
 
Actualizar Datos
 
Si se desea eliminar el registro actual del Cursor, utilice la siguiente sentencia:
 
DELETE FROM <nom tabla> WHERE CURRENT OF <cur name> ;
 

Donde:

  • · <nom tabla>, es el nombre de la Tabla a eliminar el registro.
  • · <cur name>, es el nombre del cursor.
Si se desea modificar el valor de un campo, de los seleccionados cuando se definio el cursor, utilice la siguiente sentencia:
 
UPDATE <nom table> SET <cols> WHERE CURRENT OF <cur> ;

Operador
Descripción
Next
Indica que los datos serán obtenidos del siguiente registro, de los que cumplan con la declaración del Cursor.
Prior Indica que los datos serán obtenidos del registro anterior.
First
Indica que los datos serán obtenidos del primer registro de los que cumplan con la declaración del Cursor.
Last
Indica que los datos serán obtenidos del último registro de los que cumplan con la declaración del Cursor.
 

Donde:

  • <nom table>, es el nombre de la Tabla a modificarse.
  • <cols>, es un listado de los campos, separados por coma. Nombre del campo, signo igual (=) y el valor a asignarse.
  • <cur>, nombre del cursor
Cerrar el Cursor
 
Para cerrar el cursor utilice la siguiente sentencia:
 
CLOSE <nombre cursor> ;
 
Donde: <nombre cursor>
 
El cerrar el cursor, no implica que se pueda volver a abrirlo en el futuro.
 
Métodos Find
 

Para realizar búsquedas tenemos estos 4 métodos:

  • FindFirst: busca el primer registro que cumple los criterios indicados desde el primer registro del recordset en adelante
  • FindNext: busca el siguiente registro que cumple los criterios, la búsqueda se realiza desde el último registro encontrado hasta el final del recordset.
  • FindLast: Similar a FindFirst, pero comienza a realizar la búsqueda desde el final del recordset hacia el principio
  • FindPrevious: Busca el anterior registro que cumple los criterios, la búsqueda se realiza desde el anterior registro encontrado hasta el principio del recordset.
La forma de utilizar estos métodos es la siguiente:

recordset.findfirst condición
 
La condición es una cadena de texto encerrada entre comillas en la que indicaremos el campo de la tabla que busquemos y la condición que debe cumplir. Podemos unir varias condiciones con los operadores OR y AND. La forma de introducir las condiciones es similar a como se realiza con la clausura WHERE de la sentencia SELECT de SQL.
 
Veamos algunos ejemplos:

  Recordset.FindFirst "codigo>=10 AND codigo<=20"
  Busca el primer registro cuyo campo codigo tenga un valor entre 10 y 20.
  Recordset.FindFirst "Titulo='BARCOS DE VAPOR'"
 
 
Busca el primer registro cuyo campo Titulo sea el indicado. En los campos de tipo texto el valor debe introducirse entre comillas simples.

  Recordset.FindLast "Fecha>=#1/1/95# AND Fecha<=#12/31/95#"
 
Busca el primer registro, comenzando por el final, cuyo campo fecha tenga un valor correspondiente al año 1995. Los valores tipo fecha deben introducirse con el carácter #. Y las fecha deben introducirse en formato americano, esto es, mm/dd/aa.