Como se muestra en la tabla siguiente, el código generado por EGL puede acceder a una base de datos relacional en cualquiera de los sistemas destino.
Sistema destino | Soporte para el acceso a bases de datos relacionales |
---|---|
Servicios del sistema AIX, iSeries, Linux, Windows 2000/NT/XP, UNIX | JDBC proporciona acceso a DB2 UDB, Oracle o Informix |
Mientras trabaja en un programa, puede codificar las sentencias SQL de la misma manera que lo haría para codificar programas en la mayoría de los demás lenguajes. Para facilitarle el trabajo, EGL proporciona plantillas de sentencias SQL para que las rellene.
Como alternativa, puede utilizar un registro SQL como objeto de E/S cuando codifique una sentencia EGL. Esta utilización del registro significa que accede a una base de datos personalizando una sentencia SQL que se le ha proporcionado o bien dependiendo de un valor por omisión que elimina la necesidad de codificar SQL.
select empnum, empname from employee where empnum >= :myRecord.empnum for update of empname
La tabla siguiente muestra las palabras clave EGL que puede utilizar para acceder a una base de datos relacional. Esta tabla también incluye una descripción de las sentencias SQL correspondientes a cada palabra clave. Cuando se codifica una sentencia EGL add, por ejemplo, se genera una sentencia SQL INSERT.
Puede utilizar la sentencia EGL open para llamar a un procedimiento almacenado. Este procedimiento se compone de lógica que está escrita fuera de EGL, se almacena en el sistema de gestión de bases de datos y también devuelve un conjunto de resultados. (Además, puede utilizar la sentencia EGL execute para llamar a un procedimiento almacenado).
En secciones siguientes se proporcionan detalles sobre cómo procesar un conjunto de resultados.
Si tiene la intención de codificar explícitamente sentencias SQL, utilice la sentencia EGL execute y posiblemente la sentencia EGL prepare.
Palabra clave/finalidad | Descripción de las sentencias SQL | ¿Se puede modificar la SQL? |
---|---|---|
add Coloca una fila en una base de datos; o bien (si se utiliza una matriz dinámica de registros SQL), coloca un conjunto de filas en función del contenido de los elementos sucesivos de la matriz. |
INSERT row (ya que aparece repetidamente, si especifica una matriz dinámica). | Sí |
close Libera las filas no procesadas. |
CLOSE cursor. | No |
delete Suprime una fila de una base de datos. |
DELETE row. La fila se ha seleccionado de una de las dos maneras siguientes:
|
No |
forEach Marca el inicio de un conjunto de sentencias que se ejecutan en un bucle. La primera iteración se produce solamente si un conjunto de resultados especificado está disponible y continúa (en la mayoría de los casos) hasta que se ha procesado la última fila de ese conjunto de resultados. |
EGL convierte una sentencia forEach en una sentencia FETCH de SQL que se ejecuta en un bucle. | No |
freeSQL Libera los recursos asociados a una sentencia SQL preparada dinámicamente, cerrando cualquier cursor abierto asociado con esa sentencia SQL. |
No | |
get (también llamada get by key value) Lee una única fila de una base de datos; o bien (si utiliza una matriz dinámica de registros SQL), lee filas sucesivas de elementos sucesivos de la matriz. |
SELECT row, pero sólo si establece la opción singleRow.
En caso contrario, se aplican las siguientes normas:
|
Sí |
get absolute Lee una fila especificada numéricamente en un conjunto de resultados seleccionado por una sentencia open. |
EGL convierte una sentencia get absolute en una sentencia FETCH de SQL. | No |
get current Lee la flecha en la que el cursor ya está posicionado en un conjunto de resultados seleccionado por una sentencia open. |
EGL convierte una sentencia get current en una sentencia FETCH de SQL. | No |
get first Lee la primera fila de un conjunto de resultados seleccionado por una sentencia open. |
EGL convierte una sentencia get first en una sentencia FETCH de SQL. | No |
get last Lee la última fila de un conjunto de resultados seleccionado por una sentencia open. |
EGL convierte una sentencia get last en una sentencia FETCH de SQL. | No |
get next Lee la fila siguiente de un conjunto de resultados seleccionado por una sentencia open. |
EGL convierte una sentencia get next en una sentencia SQL FETCH. | No |
get previous Lee la fila anterior de un conjunto de resultados seleccionado por una sentencia open. |
EGL convierte una sentencia get previous en una sentencia FETCH de SQL. | No |
get relative Lee una fila especificada numéricamente en un conjunto de resultados seleccionado por una sentencia open. La fila se identifica en relación con la posición del cursor en el conjunto de resultados. |
EGL convierte una sentencia get relative en una sentencia FETCH de SQL. | No |
execute Permite ejecutar una sentencia de definición de datos SQL (de tipo CREATE TABLE, por ejemplo); o una sentencia de manipulación de datos (de tipo INSERT o UPDATE, por ejemplo); o una sentencia SQL preparada que no empieza con una cláusula SELECT. |
La sentencia SQL que se escribe está disponible en el sistema de gestión de bases de datos. El uso principal de execute es codificar una única sentencia SQL que se formatea completamente durante la generación, como en el siguiente ejemplo:
try execute #sql{ // sin ningún espacio después de "#sql" delete from EMPLOYEE where department = :myRecord.department }; onException myErrorHandler(10); end Una sentencia SQL completamente formateada puede incluir variables del lenguaje principal en la cláusula WHERE. |
Sí |
open Selecciona un conjunto de filas a partir de una base de datos relacional para recuperarlas posteriormente con las sentencias get next. |
EGL convierte una sentencia open en una sentencia CALL (para acceder a un procedimiento almacenado) o en las siguientes sentencias:
|
Sí |
prepare Especifica una sentencia SQL PREPARE, que opcionalmente incluye detalles que sólo se conocen durante la ejecución; ejecute la sentencia SQL preparada ejecutando una sentencia EGL execute o (si la sentencia SQL empieza con SELECT) ejecutando una sentencia EGL open o get. |
EGL convierte una sentencia prepare en una sentencia SQL PREPARE, que siempre se construye durante la ejecución. En el siguiente ejemplo de una sentencia EGL prepare, cada marcador de parámetro (?) se resuelve mediante la cláusula USING en la sentencia execute subsiguiente: myString = "insert into myTable " + "(empnum, empname) " + "value ?, ?"; try prepare myStatement from myString; onException // salir del programa myErrorHandler(12); end try execute myStatement using :myRecord.empnum, :myRecord.empname; onException myErrorHandler(15); end |
Sí |
replace Vuelve a poner una fila cambiada en una base de datos. |
UPDATE row. La fila se ha seleccionado de una de las dos maneras siguientes:
|
Sí |
Las sentencias que abren el cursor y que actúan sobre las filas de dicho cursor están relacionadas entre sí mediante un identificador de conjunto de resultados, que debe ser exclusivo entre todos los identificadores de conjunto de resultados, variables de programa y parámetros de programa dentro del programa. Especifique dicho identificador en la sentencia open que abre el cursor, y haga referencia al mismo identificador en las sentencias get next, delete y replace que afectan a una fila individual, así como en la sentencia close que cierra el cursor. Para obtener información detallada, consulte la sección resultSetID.
VGVar.handleHardIOErrors = 1; try open selectEmp forUpdate with #sql{ // sin ningún espacio después de "#sql" select empname from EMPLOYEE where empnum >= :myRecord.empnum for update of empname }; onException myErrorHandler(8); // sale del programa end try get next from selectEmp into :myRecord.empname; onException if (sysVar.sqlcode != 100) myErrorHandler(8); // salir del programa end end while (sysVar.sqlcode != 100) myRecord.empname = myRecord.empname + " " + "III"; try execute #sql{ update EMPLOYEE set empname = :empname where current of selectEmp }; onException myErrorHandler(10); // sale del programa end try get next from selectEmp into :myRecord.empname; onException if (sysVar.sqlcode != 100) myErrorHandler(8); // sale del programa end end end // end while; el cursor se cierra automáticamente // cuando se lee la última fila del conjunto de resultados sysLib.commit;
Si desea evitar parte de la complejidad del ejemplo anterior, considere la posibilidad de utilizar registros SQL. Estos registros permiten perfeccionar el código y utilizar valores de error de E/S que no varían en los diferentes sistemas de gestión de bases de datos. El siguiente ejemplo es equivalente al anterior pero utiliza un registro SQL llamado emp:
VGVar.handleHardIOErrors = 1; try open selectEmp forUpdate for emp; onException myErrorHandler(8); // sale del programa end try get next emp; onException if (sysVar.sqlcode not noRecordFound) myErrorHandler(8); // salir del programa end end while (sysVar.sqlcode not noRecordFound) myRecord.empname = myRecord.empname + " " + "III"; try replace emp; onException myErrorHandler(10); // sale del programa end try get next emp; on exception if (sysVar.sqlcode not noRecordFound) myErrorHandler(8); // sale del programa end end end // end while; el cursor se cierra automáticamente // cuando se lee la última fila del conjunto de resultados sysLib.commit;
En las secciones siguientes se describen los registros SQL.
add EMP;
VGVar.handleHardIOErrors = 1; try add EMP; onException if (EMP is unique) // si una fila de la tabla // tenía la misma clave myErrorHandler(8); end end
Declare un componente de registro SQL y asocie cada uno de los elementos de registro con una columna de la tabla o vista relacional. Puede permitir que EGL realice esta asociación automáticamente utilizando la característica de recuperación del editor EGL, como se describe más adelante en la sección Acceso a base de datos durante la declaración.
Solo los campos de un tipo primitivo pueden representar una columna de base de datos.
Después de declarar un componente de registro SQL, declare un registro SQL que se base en dicho componente.
Puede definir un conjunto de sentencias EGL de modo que cada una de ellas utilice el registro SQL como objeto de E/S de la sentencia. Para cada sentencia, EGL proporciona una sentencia SQL implícita, que no está en el fuente pero está implícita por la combinación del registro SQL y la sentencia EGL. Por ejemplo, en el caso de una sentencia EGL add, una sentencia SQL INSERT implícita coloca el valor de un determinado elemento de registro en la columna de tabla asociada. Si el registro SQL incluye un elemento de registro para el que no se ha asignado ninguna columna de tabla, EGL forma la sentencia SQL implícita suponiendo que el nombre del elemento de registro es idéntico al nombre de la columna.
Record Employee type sqlRecord { tableNames = [["EMPLOYEE"]], keyItems = ["empnum"] } empnum decimal(6,0); empname char(40); end
get EMP;
SELECT empnum, empname FROM EMPLOYEE WHERE empnum = :empnum
INTO :empnum, :empname
Todas las variables del lenguaje principal especificadas en la propiedad defaultSelectCondition deben estar fuera del registro SQL que es la base de la matriz dinámica.
Para obtener información detallada sobre la sentencia SELECT implícita, que varía según la palabra clave, consulte las secciones get y open.
Cuando utilice registros SQL, puede relacionar las sentencias de proceso de cursores utilizando el mismo registro SQL en varias sentencias EGL, de la misma manera que puede hacerlo utilizando un identificador de conjunto de resultados. Sin embargo, cualquier relación entre sentencias que se indique mediante un identificador de conjunto de resultados tiene preferencia sobre una relación indicada mediante el registro SQL; y en algunos casos debe especificar un resultSetID.
Además, sólo un cursor puede estar abierto para un determinado registro SQL. Si una sentencia EGL abre un cursor cuando otro cursor está abierto para el mismo registro SQL, el código generado cierra automáticamente el primer cursor.
Si se elimina una sentencia SQL explícita del fuente, la sentencia SQL implícita (si existe) vuelve a estar disponible durante la generación.
DataItem DeptNo { column = deptNo } end Record Dept type SQLRecord deptNo DeptNo; managerID CHAR(6); employees Employee[]; end Record Employee type SQLRecord employeeID CHAR(6); empDeptNo DeptNo; end Function getDeptEmployees(dept Dept) get dept.employees usingKeys dept.deptNo; end
No codifique variables del lenguaje principal para indicadores de nulos en las sentencias SQL, como podría hacer en algunos lenguajes. Para probar los nulos de una variable del lenguaje principal con posibilidad de nulos, utilice una sentencia EGL if. También puede probar la recuperación de un valor truncado, pero sólo cuando un indicador de nulos está disponible.
Para conocer más detalles sobre el proceso nulo, consulte las secciones itemsNullable y Propiedades de elementos SQL.
La característica de recuperación crea elementos de registro cada uno de los cuales tiene el mismo nombre (o casi el mismo nombre) que la columna de tabla relacionada.
No se puede recuperar una vista que está definida con la condición de DB2 WITH CHECK OPTIONS.
Para obtener más información sobre cómo utilizar la característica de recuperación, consulte el apartado Recuperar datos de tabla SQL. Para obtener información detallada sobre denominación, consulte la sección Establecer las preferencias de la recuperación SQL.
Para acceder a una base de datos durante la declaración, especifique información de conexión en una página de preferencias, como se describe en la sección Establecer las preferencias de las conexiones de base de datos SQL.
Conceptos relacionados
SQL dinámico
Unidad lógica de trabajo
resultSetID
Tareas relacionadas
Recuperar datos de tabla SQL
Establecer preferencias para conexiones a bases de datos SQL
Establecer preferencias para la recuperación de SQL
Consulta relacionada
add
close
Autorización de base de datos y nombres de tabla
Base de datos por omisión
delete
execute
get
get next
Informix y EGL
itemsNullable
open
prepare
replace
Códigos de datos SQL y variables de lenguaje principal EGL
Ejemplos de SQL
Propiedades de elementos SQL
Diseño interno de los registros SQL
Componente de registro SQL en formato fuente EGL
Probar y establecer NULL