Lenguajes de consulta y definición de datos en bases de datos relacionales

3 TEMA 3. LENGUAJES DE CONSULTA Y
DEFINICION DE DATOS

3 TEMA 3. LENGUAJES DE CONSULTA Y DEFINICION DE DATOS .............. 1
3.1 Introducción...................................................................................................... 3
3.2 Estructuras lógicas de datos.............................................................................. 4
3.2.1 Tablas ....................................................................................................... 4
3.2.2 Columnas .................................................................................................. 4
3.2.3 Filas o registros......................................................................................... 4
3.2.4 Valor ......................................................................................................... 4
3.2.5 Vistas ........................................................................................................ 4
3.2.6 Indices....................................................................................................... 5
3.2.7 Clusters ..................................................................................................... 5
3.3 Expresiones....................................................................................................... 5
3.4 Tipos de datos................................................................................................... 6
3.4.1 CHAR y VARCHAR ............................................................................... 6
3.4.2 LONG ....................................................................................................... 6
3.4.3 NUMBER ................................................................................................. 7
3.4.4 DATE ....................................................................................................... 7
3.4.5 RAW y LONG RAW ............................................................................... 7
3.4.6 NULL ....................................................................................................... 7
3.5 Operadores y Funciones ................................................................................... 7
3.5.1 Operadores................................................................................................ 8
3.5.2 Funciones.................................................................................................. 9
3.6 Sentencias SQL ................................................................................................ 9
3.6.1 /* … */ COMENTARIO .......................................................................... 9
3.6.2 CREATE TABLE (DDL)....................................................................... 10
3.6.3 CREATE VIEW (DDL) ......................................................................... 10
3.6.4 CREATE INDEX (DDL) ....................................................................... 10
3.6.5 DROP object (DDL)............................................................................... 11
3.6.6 DESCRIBE (DDL) ................................................................................. 11
3.6.7 ALTER TABLE (DDL) ......................................................................... 11
3.6.8 RENAME (DDL) ................................................................................... 12
3.6.9 SELECT (DML) ..................................................................................... 12
3.6.10 INSERT (DML)...................................................................................... 13
3.6.11 DELETE (DML) .................................................................................... 13
3.6.12 UPDATE (DML).................................................................................... 14
3.6.13 LOCK TABLE (DML)........................................................................... 14
3.6.14 COMMIT (DML) ................................................................................... 14
3.6.15 ROLLBACK (DML) .............................................................................. 15
3.6.16 SAVEPOINT (DML) ............................................................................. 15
3.6.17 GRANT (DDL) ...................................................................................... 16
3.6.18 REVOKE (DDL) .................................................................................... 16
3.6.19 CONSTRAINT CLAUSE ...................................................................... 17
3.7 PL/SQL........................................................................................................... 19

Tema 3: Lenguajes de consulta y definición de datos 1

3.7.1 Estructura de un programa en PL/SQL .................................................. 20
3.7.2 Variables y constantes ............................................................................ 21
3.7.3 Cursores .................................................................................................. 21
3.7.4 %TYPE, %ROWTYPE .......................................................................... 22
3.7.5 Estructuras de control ............................................................................. 22
3.7.6 Gestión de errores................................................................................... 24
3.7.7 Delimitadores ......................................................................................... 24
3.7.8 Tipos de datos......................................................................................... 25
3.7.9 Operadores de comparación ................................................................... 25
3.7.10 Funciones................................................................................................ 26
3.7.11 Control de transacciones......................................................................... 27
3.7.12 Trabajar con Cursores............................................................................. 28
3.7.13 Subprogramas (Procedimientos y Funciones) ........................................ 31
3.7.14 Programas de ejemplo ............................................................................ 33


3.1 Introducción
El SQL es un lenguaje que permite expresar operaciones diversas, por ejemplo
aritméticas, combinatorias y lógicas, con datos almacenados en Bases de Datos
Relacionales, que son aquellas que se caracterizan porque la información está contenida
en estructuras, llamadas tablas, donde los datos están dispuestos en filas y columnas.
SQL significa Structured Query Language (Lenguaje Estructurado de Consultas).

El concepto de Base de Datos Relacional arranca de un artículo publicado en 1970 por
Codd, empleado de IBM, donde se sentaban los conceptos básicos de un modelo
relacional de datos y de un sublenguaje para acceder a ellos basado en el cálculo de
predicados. La idea se desarrolló en IBM, dando lugar a un primer prototipo llamado
System R que utilizaba un lenguaje llamado SEQUEL (que posteriormente daría lugar
al SQL).

El ANSI (American National Standards Institute) ha adoptado este lenguaje como
estándar, publicando y desarrollando unas especificaciones para este lenguaje, que has
sido posteriormente aceptadas por ISO (International Standards Organization). No
significa esto que los productos existentes sigan estrictamente esta norma,
principalmente porque el estándar no cubre todas las necesidades planteadas. Del mismo
modo, existen diferencias entre distintos productos comerciales.

Las peticiones de datos se expresan en SQL mediante sentencias que deben seguir las
normas sintácticas y semánticas del lenguaje. Estas sentencias se pueden escribir
directamente en la pantalla de un terminal interactivo, o pueden ser utilizadas
embebidas en programas, incorporándose así su capacidad expresiva a la lógica y
funciones de éstos. A ésta última forma de utilizar el SQL se le llama SQL dinámico o
embebido.

El SQL permite la realización de consultas y actualizaciones sobre datos almacenados
en tablas relacionales. Este es el principal uso que harán de él usuarios y programadores.
Pero también hay otras tareas que se pueden realizar mediante sentencias SQL, aunque
pertenecen más a las responsabilidades de los administradores de las bases de datos
(DBA). Entre estas funciones adicionales se encuentran la definición y destrucción de
objetos, y la gestión de autorizaciones de acceso.

Existen dos tipos de sentencias SQL:

• Sentencias de manipulación de datos (Data Manipulation Language).
Permiten realizar consultas y mantenimiento de los datos. Comienzan con las
siguientes palabras del lenguaje: SELECT, INSERT, UPDATE y DELETE.

• Sentencias de definición de datos (Data Definition Language). Permiten
definir nuevos objetos y/o destruir otros existentes. Algunos ejemplos de
sentencias son las de tipo CREATE y DROP.

Vamos a realizar una descripción detallada del lenguaje SQL, y de aquí en adelante
consideraremos el SGBD ORACLE como el sistema relacional base para nuestros
ejemplos. Esto implica que no todas las sentencias SQL serán estándar, pero puesto que
ORACLE es la herramienta base en las prácticas de la asignatura, se ilustrará con mayor


claridad la funcionalidad del lenguaje y dará la posibilidad de explotar de forma más
eficiente el sistema relacional empleado en las prácticas.

3.2 Estructuras lógicas de datos.
3.2.1 Tablas
Una tabla es la estructura de datos que contiene los datos en una base de datos
relacional. Una tabla se compone de filas y columnas. Una tabla puede representar una
única entidad que se desee representar en el sistema. También puede representar una
relación entre dos entidades. Aunque es posible que una tabla represente al mismo
tiempo una entidad y una relación con otra entidad, se debe tratar de separar esta
funcionalidad en la medida de lo posible.

El nombre formal para una tabla es una relación.

3.2.2 Columnas
Cada columna de una tabla representa un (y sólo un) atributo de la entidad. El nombre
de la columna debe indicar su naturaleza, en la medida de lo posible. Una columna se
identifica por su nombre, no por su posición.

El orden interno de las columnas de una tabla carece de importancia. De hecho, jamás
se conocerá el orden físico de las columnas. Se puede especificar el orden en el que
mostrar las columnas tras una selección, y por supuesto, esto no afectará al orden
interno de las columnas en la tabla.

3.2.3 Filas o registros
Los registros almacenan los datos de una tabla. Cada fila o registro representa una
ocurrencia de la entidad o relación representada en la tabla. Los registros no se deben
duplicar en una tabla, y existen mecanismos de seguridad que pueden garantizar esta
premisa (claves primarias).

El orden interno de las filas dentro de una tabla carece de importancia. De hecho, jamás
se conocerá el orden físico de las filas. Es más, no es necesario insertar filas en un
determinado orden; sólo es necesario preocuparse por el orden de recuperación de las
mismas tras una consulta.

3.2.4 Valor
Un valor es el dato referenciado por la intersección de una fila y una columna
determinadas. Los valores pertenecen al tipo de datos al que pertenece la columna, y
pueden carecer de valor (NULL).

3.2.5 Vistas
Una vista es la representación lógica de otra tabla o combinación de tablas. Una vista
obtiene sus datos de las tablas en las que se basa, que se llaman tablas base. Estas tablas
base pueden ser tablas reales u otras vistas.


Las vistas se pueden utilizar casi de igual forma que las tablas. Sin embargo, las vistas
no contienen datos, sino que, como ya hemos dicho, los obtienen de las tablas base. Por
tanto, todas las operaciones realizadas sobre las vistas afectan realmente a las tablas
base.

Las vistas se utilizan para proporcionar diferentes representaciones de los datos que
residen en otras tablas o vistas. En general, las vistas se utilizan también con los
siguientes propósitos:

• Proporcionar un nivel adicional de seguridad para las tablas a través de la
restricción a cierto numero de registros y atributos.
• Ocultar la complejidad de los datos.
• Reducir la complejidad sintáctica.
• Presentar los datos desde otra perspectiva.
• Proporcionar un nivel de integridad referencial.

3.2.6 Indices
Los índices se utilizan principalmente con dos propósitos:

• Permitir un acceso rápido a las filas de una tabla
• Forzar la unicidad de filas en una tabla

Los índices dan un acceso más rápido a los datos para operaciones que devuelven una
pequeña porción de las filas de una tabla.

Una regla importante para determinar cuando es interesante indexar un atributo de una
tabla: Las consultas SQL que devuelven menos del 15% de las filas de una tabla pueden
ser realizadas más rápidamente cuando se utilizan índices.

Los índices únicos también contribuyen a garantizar la no duplicidad de filas en una
tabla. Como regla general, siempre se debería crear un índice sobre la clave primaria de
una tabla.

3.2.7 Clusters
El clustering es un medio de estructurar datos en una o más tablas, de forma que las
filas están físicamente más juntas. El clustering es beneficioso si una aplicación
selecciona frecuentemente el mismo grupo de filas de una tabla o tablas.

El clustering puede mejorar el rendimiento de algunas operaciones; sin embargo,
también puede empeorar el de otras. Es conveniente asegurarse de las condiciones de
trabajo antes de decidir si se aplica o no clustering, y donde debe aplicarse

3.3 Expresiones
Por su importancia en los siguientes apartados, vamos a definir con cierta rigurosidad el
concepto de expresión. Su importancia es tal que una expresión forma parte de las
funciones SQL que más se utilizan en el trabajo cotidiano.

Existen varias formas de identificar una expresión:


[table.] { column | ROWID }
text
number
sequence.CURRVAL
sequence.NEXTVAL
NULL
ROWNUM
LEVEL
SYSDATE
UID
USER

: { n | variable } [ :ind_variable ]

function_name ( [DISTINCT | ALL] expr [, expr] … )

(expr)
+expr, -expr, PRIOR expr
expr * expr, expr / expr
expr + expr, expr – expr, expr || expr

(expr [, expr] … )

Las expresiones se usan en:

• Como lista de valores en la sentencia SELECT
• Como condición en las cláusulas WHERE y HAVING
• En la cláusula ORDER BY
• En la cláusula VALUE del comando INSERT
• En la cláusula SET del comando UPDATE

3.4 Tipos de datos
3.4.1 CHAR y VARCHAR
Los tipos CHAR y VARCHAR se usan para definir cadenas de texto genéricas, y puede
contener caracteres con cualquier valor ASCII. El número máximo de caracteres que
admiten es 255. La diferencia entre ambos es que mientras CHAR proporciona un
tamaño fijo para una cadena, VARCHAR admite una cantidad variable de caracteres
(Nota: al trabajar con SQL embebido esta diferencia es importante a la hora de
especificar condiciones en una sentencia).

La sintaxis para este tipo es CHAR[(n)] o VARCHAR[(n)]. Sus contenidos se
especifican entre comillas simples. Ejemplo: ‘Hola’, ‘09-MAR-98’, ‘Jackie’’s’.

3.4.2 LONG
Es un tipo de datos que se utiliza para almacenar cadenas de hasta 65,535 caracteres.
Funciona exactamente igual que el VARCHAR, pero no se puede utilizar en las
cláusulas WHERE, GROUP BY, ORDER BY, CONNECT BY y DISTINCT, ni como
índices ni dentro de funciones.


3.4.3 NUMBER
Se utiliza para almacenar números con una precisión máxima de 38 dígitos (lo que
incluye números desde 1.0E-129 hasta 9.99E124), y una escala que va desde –84 hasta
127.

La sintaxis para este tipo es NUMBER[(precisión [, escala])]. Algunos ejemplos:

7,456,123.89 NUMBER 7,456,123.89
7,456,123.89 NUMBER(9) 7,456,123
7,456,123.89 NUMBER(9,1) 7,456,123.9
7,456,123.89 NUMBER(9,2) 7,456,123.89
7,456,123.89 NUMBER(9,-2) 7,456,100

Otros tipos de datos válidos que se incluyen por compatibilidad son DECIMAL,
INTEGER, SMALLINT, FLOAT, REAL, y DOUBLE_PRECISION. Algunos ejemplos
de datos numéricos: 7, 255, 29K, 6M, 3.56, 7E5, 3e-2.

3.4.4 DATE
Se usa para almacenar información de fechas y horas. Almacena información de siglo,
año, mes, día, hora, minuto y segundo. Por defecto se toma la hora 00:00:00, y el
formato de fecha por defecto es DD-MON-YY. Existen funciones TO_DATE y
TO_CHAR para convertir entre distintos formatos.

Por ejemplo, TO_DATE(‘13-NOV-85 10:56 A.M.’, ‘DD-MON-YY HH:MI A.M.’)

3.4.5 RAW y LONG RAW
Se utilizan para tipos de datos binarios, es decir, con caracteres que no pertenecen todos
al código ASCII. RAW tiene un máximo de contenido de 255, y LONG RAW hasta
65,535. Funcionan igual que el VARCHAR y LONG VARCHAR.

Hay que introducir los datos en formato hexadecimal.

3.4.6 NULL
No se trata de un tipo de datos concreto. Es más bien un valor que indica la ausencia de
cualquier valor para un determinado literal (o columna).

Para comparar valores con NULL sólo se pueden usar los operadores IS NULL o IS
NOT NULL.

3.5 Operadores y Funciones
Existen en ORACLE muchos operadores y funciones. Nosotros sólo vamos a tratar las
más corrientes y que más uso pueden tener dentro del uso habitual del sistema (para más
información se puede consultar el SQL Language Reference Manual).


3.5.1 Operadores
3.5.1.1 Operadores aritméticos

() Operador de precedencia
+- Denota un número positivo o negativo
*/ Multiplicar o dividir
+- Sumar o restar

3.5.1.2 Operadores de comparación

= Comparación
!=, ^=, <> Distinto
>, < Mayor que, menor que
>=, <= Mayor o igual que, menor o igual que
[NOT] IN Pertenencia a un conjunto (equivalente a =ANY)
ANY Compara un valor con cada valor devuelto en una lista o subconsulta.
Debe ir precedido de los operadores =, !=, >, >=, <, <=.
ALL Compara un valor con todos los devueltos por una lista o subconsulta.
Debe ir precedido de los operadores =, !=, >, >=, <, <=.
[NOT]
BETWEEN x Entre x e y.
AND y
[NOT]
EXISTS Cierto [Falso] si la subconsulta devuelve al menos una fila.
[NOT] LIKE Patrón de comparación. Los caracteres universales son % (*) y _(?).
IS [NOT]
NULL Se usa para comprobar si un valor es o no nulo.

3.5.1.3 Operadores lógicos

NOT Operador booleano de negación.
AND Operador booleano de multiplicación.
OR Operador booleano de suma.

3.5.1.4 Operadores de conjuntos

UNION Operador de unión de conjuntos.
INTERSECT Operador de intersección de conjuntos.
MINUS Operador de resta de conjuntos.

3.5.1.5 Otros operadores

[tabla.]* Selecciona todas las columnas de una tabla en una consulta.
COUNT(exp) Devuelve el número de columnas donde exp no es nulo.
COUNT(*) Devuelve el número total de columnas en una tabla.
ALL Fuerza a devolver valores duplicados en una consulta (lo que se trata de
evitar con el DISTINCT).
DISTINCT Elimina filas duplicadas en una tabla devuelta.


3.5.2 Funciones

ABS(n) Devuelve el valor absoluto de n
CEIL(n) Devuelve el menor entero mayor o igual que n
FLOOR(n) Devuelve el mayor entero menor o igual que n
MOD(m,n) Resto de la división
POWER(m,n) Potencia: m elevado a n
SQRT(n) Raíz cuadrada (NULL si n<0)

CHR(n) Devuelve el carácter con código ASCII n
LOWER(char) Convierte la cadena a lowercase
LPAD(char1,n [,char2]) Rellena char1 por la izquierda hasta llegar a los n
caracteres con los caracteres especificados en char2
(blancos por defecto).
RPAD(char1,n [,char2]) Lo mismo que LPAD, pero por la derecha
LTRIM(char1[,char2]) Elimina de la cadena char1 los primeros caracteres
que coincidan con la cadena char2. Por defecto,
char2 es un espacio en blanco.
RTRIM(char1[,char2]) Elimina de la cadena char1 los últimos caracteres
que coincidan con la cadena char2. Por defecto,
char2 es un espacio en blanco.
UPPER(char) Convierte la cadena a uppercase.
ASCII(char) Devuelve el código ASCII del carácter
LENGTH(char) Devuelve la longitud de la cadena

AVG([DISTINCT|ALL] n) Devuelve la media, ignorando los valores nulos.
COUNT([DISTINCT|ALL] expr) Devuelve el número de filas donde expr no es nulo.
MAX([DISTINCT|ALL] expr) Devuelve el máximo valor de expr.
MIN([DISTINCT|ALL] expr) Devuelve el mínimo valor de expr.
SUM([DISTINCT|ALL] n) Devuelve la suma de los valores de n.

3.6 Sentencias SQL
3.6.1 /* … */ COMENTARIO
Se puede incluir cualquier comentario en una sentencia SQL, situándolo entre los
símbolos ‘/*’ y ‘*/’ (igual que en C y C++). Los comentarios pueden ocupar más de una
línea, y pueden estar intercalados en cualquier posición de la sentencia SQL.

Ejemplo:

SELECT ENAME
/* Se selecciona los números de empleado */
FROM EMP
/* de la tabla empleado */


3.6.2 CREATE TABLE (DDL)
Crea una tabla, la estructura básica para mantener los datos en la BD. Una tabla puede
tener hasta 254 columnas.

Sintaxis:

CREATE TABLE [user.]table
( { column_element | table_constraint }
[,{ column_element | table_constraint } ] … )
[TABLESPACE tablespace]
[AS query]

Ejemplo:

CREATE TABLE EMP
(EMPNO NUMBER NOT NULL PRIMARY KEY,
ENAME CHAR(10) NOT NULL CHECK(ENAME=UPPER(ENAME)),
DEPTNO NUMBER(2),
FOREIGN KEY (DEPTO) REFERENCES DEPT(DEPTNO));

3.6.3 CREATE VIEW (DDL)
Define una vista (una tabla lógica basada en una o más vistas).

Sintaxis:

CREATE VIEW [user.]view [ ( alias [, alias] … ) ]
AS query
[WITH CHECK OPTION [CONSTRAINT constraint] ]

Ejemplo:

CREATE VIEW ROSTER (ID, DEPTNO)
AS SELECT EMPNO, DEPTNO FROM EMP
WHERE DEPTNO IN (SELECT DISTINCT DEPTNO FROM DEPT)
WITH CHECK OPTION CONSTRAINT WCO;

(La opción with check option impide insertar una fila cuyo numero de departamento no
exista en la tabla DEPTNO. La fila será realmente insertada en la tabla EMP sólo si se
cumple la condición.)

3.6.4 CREATE INDEX (DDL)
Crea un índice para una tabla. El índice proporciona acceso directo a las filas de la tabla,
reduciendo el tiempo de acceso. Un índice contiene una entrada para cada valor que
aparece en la columna indexada.

Sintaxis:


CREATE [UNIQUE] INDEX index ON
{ table ( column [ASC|DESC] [, column [ASC|DESC] ] … )
CLUSTER cluster}
[TABLESPACE tablespace]
[NOSORT]

Ejemplo:

CREATE UNIQUE INDEX I_EMP$EMPNO ON EMP (EMPNO);

3.6.5 DROP object (DDL)
La sentencia DROP sirve para borrar objetos de la base de datos. Se puede utilizar
directamente sobre tablas, vistas e índices.

Sintaxis:

DROP TABLE [user.]table

DROP VIEW [user.]view

DROP INDEX [user.]index

Ejemplo:

DROP TABLE MY_TEST

DROP VIEW MY_VIEW

DROP INDEX MY_INDEX

3.6.6 DESCRIBE (DDL)
Muestra información sobre la estructura de una tabla o vista.

Sintaxis:

DESCRIBE [user.]table

Ejemplo:

DESCRIBE EMP;

3.6.7 ALTER TABLE (DDL)
Permite alterar la definición de una tabla con las siguientes posibilidades:

• Añadir columnas o restricciones
• Modificar definiciones de columnas


• Eliminar restricciones
• Indicar que se ha realizado un backup de la tabla

Sintaxis:

ALTER TABLE [user.]table
[ADD ( {column_element | table_constraint}
[,{column_element | table_constraint} ] … ) ]
[MODIFY (column_element [,column_element] …) ]
[DROP CONSTRAINT constraint] …
[BACKUP]

Ejemplo:

ALTER TABLE EMP
ADD (THRIFTPLAN NUMBER(7,2), LOANCODE CHAR(1));

ALTER TABLE EMP
MODIFY (THRIFTPLAN NUMBER(9,2))
DROP CONSTRAINT ENAME_CNSTR;

3.6.8 RENAME (DDL)
Se utiliza para renombrar una tabla o vista. No se pueden renombrar columnas.

Sintaxis:

RENAME old TO new

Ejemplo:

RENAME DEPT TO EMP_DEPT;

CREATE TABLE TEMPORARY (NEWNAME)
AS SELECT OLDNAME FROM STATIC;
DROP TABLE STATIC;
RENAME TEMPORARY TO STATIC;

3.6.9 SELECT (DML)
Se utiliza para mostrar filas y columnas de una o más tablas, siguiendo ciertas
condiciones y aplicando determinadas operaciones.

Sintaxis:

SELECT [ALL|DISTINCT] { * | table.* | expr [c_alias] }
[, { * | table.* | expr [c_alias] } ] …
FROM [user.]table [t_alias] [,[user.]table [t_alias]]…
[WHERE contition]
[GROUP BY expr [, expr] … [HAVING condition] ]
[{UNION|INTERSECT|MINUS} SELECT …]


[ORDER BY {expr|position} [ASC|DESC]
[,{expr|position} [ASC|DESC] ] ]

Ejemplo:

SELECT ENAME, SAL, JOB, DEPTNO
FROM EMP
WHERE DEPTNO = 30;

SELECT DEPTNO, MIN(SAL), MAX(SAL)
FROM EMP
WHERE JOB = ‘CLERK’
GROUP BY DEPTNO
HAVING MIN(SAL)>1000;

3.6.10 INSERT (DML)
Se utiliza para insertar nuevos registros en las tablas o vistas (la tabla base de la vista).

Sintaxis:

INSERT INTO [user.]table [ (column [, column] … ) ]
{ VALUES (value [, value] … ) | query }

Ejemplo:

INSERT INTO EMP (EMPNO, ENAME, JOB, SAL, COMM, DEPTNO)
VALUES (7980, ‘JINKS’, ‘CLERCK’, 1.2E3, NULL, 40);

INSERT INTO BONUS
SELECT ENAME, JOB, SAL, COMM FROM EMP
WHERE COMM < 25 * SAL OR JOB IN (‘PRESIDENT’, ‘MANAGER’);

3.6.11 DELETE (DML)
Elimina registros de una tabla.

Sintaxis:

DELETE [FROM] [user.]table [alias] [WHERE condicion]

Ejemplo:

DELETE FROM TEMP_ASSIGN;

DELETE FROM EMP
WHERE JOB = ‘SALESMAN’
AND COMM < 100;


3.6.12 UPDATE (DML)
Se utiliza para modificar los datos de una tabla

Sintaxis:

UPDATE [user.]table [alias]
SET column = expr [, column = expr] …
[WHERE condition]

UPDATE [user.]table [alias]
SET (column [,column] …) = (query)
[,(column [,column] …) = (query) ] …
[WHERE condition]

Ejemplo:

UPDATE EMP
SET COMM = NULL
WHERENJOB = ‘TRAINEE’;

3.6.13 LOCK TABLE (DML)
Se utiliza para bloquear una o más tablas en el modo especificado, permitiendo
compartir o denegar el acceso a la tabla mientras dure la operación en curso.

Sintaxis:

LOCK TABLE [user.]table [, [user.]table ]…
IN lockmode MODE [NOWAIT]

Siendo lockmode =
ROW SHARE (permite acceso concurrente. Prohiben los bloqueos de
tipo exclusivo. = SHARE UPDATE)
ROW EXCLUSIVE (prohibe igual que ROW SHARE, pero además
impide los bloqueos en modo SHARE)
SHARE UPDATE (permite acceso concurrente. Prohiben los bloqueos
de tipo exclusivo. = ROW SHARE)
SHARE (permite consultas concurrentes, pero no actualizaciones)
SHARE ROW EXCLUSIVE (permite consultas en una tabla y prohibe a
otros bloquearla en modo SHARE o actualización de registros)
EXCLUSIVE (sólo permite consultas)

Ejemplo:

LOCK TABLE EMP IN EXCLUSIVE MODE NOWAIT

3.6.14 COMMIT (DML)
El comando COMMIT se utiliza para:

• Hacer permanentes los cambios de la transacción actual


• Borrar los savepoints de una transacción
• Finalizar la transacción
• Eliminar los bloqueos de la transacción.

Sintaxis:

COMMIT [WORK]

WORK se usa por compatibilidad ANSI

Ejemplo:

COMMIT

3.6.15 ROLLBACK (DML)
Se utiliza para deshacer todo lo realizado en la actual transacción. El uso del
ROLLBACK sin un SAVEPOINT hace:

• Finaliza la transacción
• Deshace los cambios realizados durante la última transacción
• Elimina los savepoints de la transacción
• Elimina los bloqueos de la transacción

Si se usa con un SAVEPOINT se produce:

• Deshace sólo una porción de la transacción
• Mantiene el savepoint especificado, pero elimina los posteriores
• Elimina los bloqueos producidos después del establecimiento del savepoint

Sintaxis:

ROLLBACK [WORK]
[TO [SAVEPOINT] savepoint]

Ejemplo:

ROLLBACK;

ROLLBACK TO SAVEPOINT SP5;

3.6.16 SAVEPOINT (DML)
Identifica un punto en una transacción que permite recuperar con posterioridad el estado
de la base de datos justo en ese momento a través del comando ROLLBACK.

Sintaxis:

SAVEPOINT savepoint


Ejemplo:

SAVEPOINT SP1;

3.6.17 GRANT (DDL)
Sirve par varios propósitos:

• Proporcionar acceso a una base de datos (y cambiar passwords)
• Proporcionar acceso a un espacio de tablas con límite de espacio
• Proporcionar varios tipos de acceso a objetos de la base de datos

Sintaxis:

GRANT dabase_priv [, databse_priv] …
TO user [, user] …
[IDENTIFIED BY password [, password] … ]

Siendo database_priv = DBA | CONNECT | RESOURCE

GRANT RESOURCE [ (quota [k|m] ) ]
ON tablespace
TO { PUBLIC | user [, user] … }

Siendo quota el espacio en bytes.

GRANT { object_priv [, object_priv] … | ALL [PRIVILEGES] }
ON [user.]object
TO { user | PUBLIC } [, user] …
[WITH GRANT OPTION]

Siendo object_priv = ALTER | DELETE | INDEX | INSERT | REFERENCES |
SELECT | UPDATE. Si se utiliza UPDATE o REFERENCES, se pueden
especificar columnas.

Ejemplo:

GRANT CONNECT, RESOURCE TO SCOTT IDENTIFIED BY TIGER;

GRANT RESOURCE (10M) ON FINANCE TO SCOTT;

GRANT ALL ON BONUS TO JONES WITH GRANT OPTION;
GRANT SELECT, UPDATE ON GOLF_HANDICAP TO PUBLIC;

3.6.18 REVOKE (DDL)
Sirve para realizar todo lo contrario que GRANT:

• Eliminar privilegios de la base de datos para uno o varios usuarios
• Eliminar privilegios de los espacios de tablas para usuarios


• Eliminar privilegios de acceso para usuarios de una o varias tablas, vistas y
secuencias

Sintaxis:

REVOKE { [CONNECT] [, RESOURCE] [,DBA] }
FROM user [, user]

REVOKE space_privilege ON tablespace
FROM user [, user]

REVOKE {object_priv [, object_priv] … | ALL [PRIVILEGES] }
ON [user.]object
FROM {user | PUBLIC} [,user] …

Ejemplo:

REVOKE RESOURCE FROM SCOTT, JOLLY_ROGER;

REVOKE RESOURCE ON SYSTEM FROM SCOTT;

REVOKE ALTER, DELETE, INSERT, UPDATE ON DEPT10 FROM JONES;

3.6.19 CONSTRAINT CLAUSE
Las cláusulas de restricción sirven para limitar el rango de valores válidos para una
columna o grupo de columnas de una tabla. Las sentencias INSERT, UPDATE y
DELETE obligan a la evaluación de las cláusulas de restricción, que deben ser
satisfechas para que las sentencias se ejecuten con éxito.

Básicamente, las restricciones se usan para:

• Imponer que los valores de un atributo dado no pueden ser nulos (NOT
NULL)
• Imponer que el valor de una columna debe ser único en toda la tabla
(UNIQUE)
• Identificar una columna o grupo de columnas como clave primaria de una
tabla.
• Identificar el valor de una columna o conjunto de columnas como clave
ajena en otra tabla.
• Obligar a que los valores de una columna satisfagan una expresión o estén
dentro de un conjunto de valores predeterminado.

Sintaxis:

Para una tabla:

[{UNIQUE | PRIMARY KEY} (column [, column] … )
[CONSTRAINT constraint] ]
[FOREIGN KEY (column [, column] … )
REFERENCES [user.]table [(column [, column] … ) ]
[CONSTRAINT constraint]
[CHECK (condition) [CONSTRAINT constraint] ]


Para una columna:

Column [NULL] | [NOT NULL [CONSTRAINT constraint] ]
[ { UNIQUE | PRIMARY KEY } [CONSTRAINT constraint] ]
[REFERENCES [user.]table [(column)] ] [CONSTRAINT constraint]
[CHECK (condition) [CONSTRAINT constraint ]

Ejemplo:

CREATE TABLE P_E
(PROJECT NUMBER,
EMPLOYEE NUMBER,
PRIMARY KEY ( PROJECT, EMPLOYEE));

o

CREATE TABLE p_e
(DEPTNO NUMBER PRIMARY KEY, …);

CREATE TABLE EMP
(EMPNO NUMBER(5) NOT NULL CONSTRAINT NN_CONSTRNT);

Nota: Caso especial para la creación de tablas. En ORACLE, cuando se desea mantener
completamente la integridad referencial con opciones, se puede utilizar lo siguiente:

Sintaxis:

FOREIGN KEY ()
REFERENCES ()
ON { DELETE | MODIFY } { RESTRICT | CASCADE | SET NULL }


3.7 PL/SQL
PL/SQL es un lenguaje de programación avanzado de cuarta generación (4GL). Es la
extensión procedural que proporciona Oracle al SQL. El objetivo de Oracle al
proporcionar este lenguaje fue ofrecer una herramienta de fácil uso para obtener un
acceso a la información almacenada en una base de datos Oracle, a través de la
inclusión de sentencias SQL embebidas dentro de un lenguaje de programación de alto
nivel.

La idea del SQL embebido no es nueva, ni se le debe a Oracle. El SQL embebido es un
método de programación que permite acceder a las bases de datos a través de sentencias
SQL que se declaran dentro de un programa de alto nivel, y que permiten tanto obtener
información de la base de datos como actualizarla.

El modo de trabajo cuando se utiliza SQL embebido dentro de un programa es
ligeramente diferente al modo de proceder cuando se realiza un programa normal. Lo
habitual es realizar un programa cuyo código fuente se compila y se obtiene un
ejecutable que realiza las tareas programadas. Sin embargo, cuando se utiliza SQL
embebido, el proceso consta de tres fases en lugar de dos: la primera es igual que en el
caso anterior, es decir, la creación del código fuente, esta vez con sentencias SQL
apropiadamente declaradas dentro del código; la segunda es distinta, y en este caso
consiste en un proceso de pre-compilación, donde todas las sentencias SQL se
convierten a código del lenguaje de alto nivel que se está utilizando; la tercera y última
corresponde a la segunda fase del caso anterior, y no es más que la compilación final del
código fuente resultado de la pre-compilación, con lo que se obtiene un código
ejecutable.

En particular, el procesamiento que se realiza de los programas PL/SQL por parte de
Oracle sigue la siguiente arquitectura:


Veamos ahora un ejemplo de un programa realizado en PL/SQL, lo que nos dará una
mejor idea del tipo de programación que estamos definiendo:
DECLARE
qty_on_hand NUMBER(5);
BEGIN
SELECT quantity INTO qty_on_hand FROM inventory
WHERE product = 'TENNIS RACKET'
FOR UPDATE OF quantity;
IF qty_on_hand > 0 THEN -- check quantity
UPDATE inventory SET quantity = quantity - 1
WHERE product = 'TENNIS RACKET';
INSERT INTO purchase_record
VALUES ('Tennis racket purchased', SYSDATE);
ELSE
INSERT INTO purchase_record
VALUES ('Out of tennis rackets', SYSDATE);
END IF;
COMMIT;
END;

Como se puede apreciar, en un programa escrito en PL/SQL se pueden utilizar
sentencias para manipular los datos de una base de datos, pero también se pueden
utilizar sentencias de control para procesar los datos. También es posible declarar
funciones, procedimientos, constantes, variables, y se puede hacer un tratamiento de los
errores (gestión de errores).

3.7.1 Estructura de un programa en PL/SQL
Viendo el programa anterior, se aprecia un primer bloque de declaración de variables,
seguido en una secuencia BEGIN..END; que contiene el cuerpo del programa principal.
Las sentencias SQL que se encuentran se ejecutan directamente contra la base de datos
y tanto recogen como actualizan datos. Las sentencias de control (IF-ELSE-END IF)
permiten decidir que acciones realizar según las condiciones de trabajo.

En general, la estructura de bloques que se puede tener en un programa escrito en
PL/SQL es la siguiente:

donde se aprecia un primer bloque para las definiciones que es opcional, un segundo
bloque que contiene el código del programa, y un último bloque, llamado de
excepciones, incluido en el bloque principal, que define las acciones a realizar en caso
de errores, y también es opcional.


3.7.2 Variables y constantes
Las variable pueden ser definidas de cualquier tipo SQL. Por ejemplo:
part_no NUMBER(4);
in_stock BOOLEAN;

La asignación de valores a las variables se hace a través de dos modos distintos. El
primero consiste en utilizar el operador := tal y como se ve en los ejemplos siguientes:
tax := price * tax_rate;
bonus := current_salary * 0.10;
amount := TO_NUMBER(SUBSTR('750 dollars', 1, 3));
valid := FALSE;

El segundo consiste en obtener datos de una consulta y guardarlos en variables definidas
con anterioridad, como por ejemplo:
SELECT sal * 0.10 INTO bonus FROM emp WHERE empno = emp_id;

En este caso, la variable ‘bonus’ tomará el valor definido por el 10% del salario de un
empleado en concreto.

La declaración de constantes se hace igual que la declaración de variables, pero se
añade la palabra reservada CONSTANT y de forma inmediata se debe definir un valor
para dicha constante:
credit_limit CONSTANT REAL := 5000.00;

3.7.3 Cursores
Oracle utiliza áreas de trabajo para ejecutar sentencias SQL y almacenar la información
que se va a procesar. Por ejemplo, cuando se desea utilizar una sentencia SQL que
recupere más de un registro de una tabla, la información no se podrá recuperar toda de
golpe, sino que se tendrá que proceder registro a registro. Para ello se utilizan los
cursores, es decir, para reservar una zona de memoria donde se recibirá la información
del registro, y poder procesar así todos los registros objeto de la consulta.

La definición de cursores se realiza del siguiente modo:
DECLARE
CURSOR c1 IS
SELECT empno, ename, job FROM emp WHERE deptno = 20;

es decir, dentro del bloque de declaraciones se especifica la palabra CURSOR, a
continuación el nombre del cursor (c1 en este caso) y luego la palabra IS seguida de la
sentencia SQL que se pretende procesar.

Trabajar con cursores en PL/SQL es relativamente sencillo: basta con declarar el cursor,
y construir después un bucle en el programa principal que recorra todos los elementos
del cursor. Un ejemplo de cómo realizar este procesamiento es:


DECLARE
CURSOR c1 IS
SELECT ename, sal, hiredate, deptno FROM emp;
...
BEGIN
FOR emp_rec IN c1 LOOP
...
salary_total := salary_total + emp_rec.sal;
END LOOP;

Obsérvese que la variable emp_rec no se ha definido con anterioridad. Este es un
método habitual de trabajo con cursores, es decir, una vez definido el cursor, se crea un
bucle (FOR...IN...LOOP - END LOOP) donde el acceso a los elementos del cursor se
realiza utilizando el nombre de la variable definido en el LOOP, un punto como
separador de estructura (contenidos) y luego los atributos seleccionados con la sentencia
SQL (emp_rec.sal).

3.7.4 %TYPE, %ROWTYPE
Existe una forma cómoda de declarar variables de tipos de tablas que vamos a utilizar
en consultas SQL. Si no recordamos exactamente el tipo de un atributo de una tabla,
podemos utilizar el operador %TYPE para indicar que una variable es del tipo de un
atributo de una tabla, por ejemplo:
my_title books.title%TYPE;

Esta declaración indica que la variable my_title es del tipo del atributo title de la tabla
books. Si lo que deseamos es, sin embargo, declarar una variable de tipo registro que
contenga todos los atributos de una tabla, lo haremos del siguiente modo:
dept_rec dept%ROWTYPE;

lo que indica en este caso que la variable dept_rec es un registro (contiene todos los
campos) de la tabla dept. En este caso, se utiliza una notación de “.” para indicar los
campos de un registro (por ejemplo, dept_rec.deptno hará referencia al campo deptno de
la tabla dept).

Las variables de tipo registro se suelen utilizar para recoger la información de una tabla
dentro de un cursor. El siguiente ejemplo muestra como se realizaría esta acción:
DECLARE
CURSOR c1 IS
SELECT ename, sal, hiredate, job FROM emp;
emp_rec c1%ROWTYPE;
Posteriormente, dentro del cursor, se realizaría la siguiente acción:
FETCH c1 INTO emp_rec;

3.7.5 Estructuras de control
Como ya hemos mencionado con anterioridad, es posible utilizar estructuras de control
en un programa PL/SQL para decidir dinámicamente que acciones realizar en función
de ciertos parámetros o valores de variables que se den en un momento dado. Las
estructuras de control de que disponemos en PL/SQL son las siguientes:


3.7.5.1 Control condicional

IF condición THEN
sentencias
ELSE
sentencias
END IF;

IF condición THEN
sentencias
ELSIF condición THEN
sentencias
ELSE
sentencias
END IF;

Con esta estructura se ejecutarán las sentencias que estén a continuación del THEN
cuando la condición que se evalúa sea cierta, y se ejecutarán las sentencias a
continuación del ELSE cuando la condición sea falsa.

3.7.5.2 Control iterativo

LOOP
sentencias
END LOOP;

Esta es una estructura que se repetirá iterativamente mientras se satisfaga cierta
condición. La forma de proporcionar la condición de control varía según los siguientes
casos:

WHILE condición LOOP
sentencias
END LOOP;

FOR variable IN valor_minimo..valor_máximo LOOP
sentencias
END LOOP;

Siempre es posible salir de un bucle repetitivo utilizando la sentencia:

EXIT;

o bien

EXIT WHEN condición;

lo cual proporciona más control sobre las acciones que se están realizando dentro de los
bucles. La sentencia EXIT proporciona una salida inmediata del bucle, mientras que la
sentencia EXIT WHEN lo hace cuando se cumple la condición indicada.


3.7.6 Gestión de errores
La gestión de los errores permite en un programa PL/SQL decidir que tratamiento se
debe proporcionar a un a línea del proceso que hay generado un error, o a cualquier
circunstancia no deseada en el flujo normal del programa, y abortarlo tras realizar el
tratamiento oportuno del error. Como ya hemos mencionado con anterioridad, este
procesamiento se hace a través del bloque EXCEPTION. Un ejemplo que muestra un
tratamiento de errores es el siguiente:
DECLARE
...
comm_missing EXCEPTION; -- declaración de la excepción
BEGIN
...
IF commission IS NULL THEN
RAISE comm_missing; -- lanzar la excepción
END IF;
bonus := (salary * 0.10) + (commission * 0.15);
EXCEPTION
WHEN comm_missing THEN ... -- procesar la excepción
WHEN OTHERS THEN ... -- procesar cualquier otra excepción
END;

Existen una serie de excepciones definidas en el sistema que se lanzan automáticamente
sin que sean declaradas en los programas. Por ejemplo, cuando se intenta hacer una
división por cero, se lanza la excepción ZERO_DIVIDE, que puede ser tratada dentro
del programa o puede ser tratada por defecto por el sistema.

3.7.7 Delimitadores
Los símbolos que se pueden utilizar como delimitadores en un programa PL/SQL son
los siguientes y tienen el siguiente significado:

SIMBOLO SIGNIFICADO
+ Operador suma
% Indicador de atributo
‘ Delimitador de cadenas o caracteres
. Delimitador de componentes
/ Operador división
( Delimitador de expresión
) Delimitador de expresión
: Indicador de variable huésped
, Separador de items
* Operador multiplicación
“ Delimitador de identificadores
= Operador comparador igual que
< Operador comparador menor que
> Operador comparador mayor que
; Final de sentencia
- Operador resta
:= Operador asignación


|| Operador concatenación de cadenas
** Operador elevado
/* Inicio de comentario
*/ Fin de comentario
.. Operador de rango
!= Operador de comparación distinto
<> Operador de comparación distinto
<= Operador de comparación menor o igual
>= Operador de comparación mayor o igual
-- Comentario de una línea

3.7.8 Tipos de datos
Los tipos de datos que se pueden utilizar en un programa PL/SQL son los siguientes:

Es posible también definir subtipos utilizando la siguiente sentencia:

SUBTYPE subtype_name IS base_type [NOT NULL];

pero siempre se tratará de tipos definidos en base a tipos predefinidos o subtipos
definidos por el usuario.

3.7.9 Operadores de comparación
Además de los operadores que hemos visto como delimitadores o símbolos que utiliza
PL/SQL como operadores, existen una serie de operadores para realizar operaciones no


numéricas, pero que tienen perfecto sentido dentro del ámbito de trabajo en el que
estamos. A continuación se presentan los principales operadores adicionales:

IS NULL variable. Operador que devuelve un valor booleano verdadero o falso según
la variable sea nula o no nula.

variable LIKE valor. Operador que devuelve un valor booleano verdadero o falso según
la cadena almacenada en variable sea igual al dato valor. No se debe confundir este
operador con el de igualdad, que aunque se puede aplicar a cadenas, no permite el uso
de caracteres universales (%, _).

variable BETWEEN valor1 AND valor2. Operador que devuelve un valor booleano
verdadero o falso según la variable esté o no comprendida entre los valores valor1 y
valor2

variable IN conjunto. Operador que devuelve un valor booleano según el valor de la
variable se encuentre dentro de un conjunto de valores.

3.7.10 Funciones
PL/SQL permite la utilización de funciones predefinidas para trabajar con varios tipos
de datos: números, caracteres, fechas, referencias de objetos, etc. Además existe un
conjunto de funciones de propósito general y otro conjunto de funciones que permiten
realizar conversiones entre tipos de datos. Se presenta a continuación una lista que
muestra un esquema de las funciones predefinidas del ámbito de aplicación de cada una
de ellas:

Funciones sobre errores: SQLCODE, SQLERRM.

Funciones sobre números: ABS, ACOS, ASIN, ATAN, ATAN2, CEIL, COS, COSH,
EXP, FLOOR, LN, LOG, MOD, POWER, ROUND, SIGN, SIN, SINH, SQRT, TAN,
TANH, TRUNC.

Funciones sobre caracteres: ASCII, CHR, CONCAT, INITCAP, INSTR, INSTRB,
LENGTH, LENGTHB, LOWER, LPAD, LTRIM, NLS_INITCAP, NLS_LOWER, NLSSORT,
NLS_UPPER, REPLACE, RPAD, RTRIM, SOUNDEX, SUBSTR, SUBSTRB, TRANSLATE,
TRIM, UPPER.

Funciones de conversión: CHARTOROWID, CONVERT, HEXTORAW, RAWTOHEX,
ROWIDTOCHAR, TO_CHAR, TO_DATE, TO_MULTI_BYTE, TO_NUMBER, TO_SINGLE_BYTE.

Funciones de fecha: ADD_MONTHS, LAST_DAY, MONTHS_BETWEEN, NEW_TIME,
NEXT_DAY, ROUND, SYSDATE, TRUNC.

Funciones de referencia de objetos: DEREF, REF, VALUE

Funciones de propósito general: BFILENAME, DECODE, DUMP, EMPTY_BLOB,
EMPTY_CLOB, GREATEST, LEAST, NLS_CHARSET_DECL_LEN, NLS_CHARSET_ID,
NLS_CHARSET_NAME, NVL, SYS_CONTEXT, SYS_GUID, UID, USER, USERENV, VSIZE.


3.7.11 Control de transacciones
El control de transacciones consiste en una serie de técnicas que permiten salvaguardar
la consistencia de la base de datos, incluyendo la manera de controlar cuando los
cambios realizados en una base de datos deben ser permanentes o deben desecharse.

Una transacción consiste en una serie de sentencias DML de SQL que componen una
unidad lógica. Normalmente, las bases de datos tratan cada una de las sentencias SQL
como unidades lógicas, pero es necesario que las bases de datos proporcionen
mecanismos para poder agrupar conjuntos de sentencias como unidades lógicas. Las
sentencias que se pueden utilizar para trabajar con estas agrupaciones lógicas o
transacciones son las siguientes:

COMMIT. Valida los cambios realizados en la base de datos por la transacción actual.

ROLLBACK. Deshace todos los cambios realizados en la base de datos por la
transacción actual.

SAVEPOINT. Sitúa puntos de control dentro de la transacción y permite deshacer
cambios en la base de datos de forma parcial por la transacción.

SET TRANSACTION. Permite configurar las propiedades de la transacción, como
lectura/escritura y nivel de aislamiento.

Una transacción, pues, está definida como el conjunto de sentencias entre un COMMIT
y el siguiente COMMIT. COMMIT se debe utilizar para validar los cambios realizados
en una base de datos, siempre y cuando la consistencia de la base de datos esté
asegurada. ROLLBACK se debe utilizar para recuperar el estado de la base de datos al
comienzo de la transacción si alguna de las sentencias de la transacción ha fallado o ha
generado resultados no deseados. SAVEPOINT se debe utilizar para marcar puntos de
control que ofrezcan estados consistentes de la base de datos, y poder volver a ellos
cuando sea necesario con la sentencia ROLLBACK TO SAVEPOINT sp. Por último,
SET TRANSACTION se debe utilizar para configurar ciertos parámetros de las
transacciones para determinar niveles de aislamiento y modo de trabajo
lectura/escritura.

El comportamiento que cabe esperar de la base de datos ante las transacciones lo
definiremos a continuación. En primer lugar, cuando falla una sentencia SQL simple, la
base de datos hará un rollback de la sentencia exclusivamente. Si por algún motivo el
programa terminase debido a una excepción no tratada, la base de datos no hará un
rollback de forma implícita. Por consiguiente, habrá que tener especial cuidado en la
gestión de las excepciones. Cuando se realiza un rollback hasta un savepoint
determinado, todos los savepoints definidos con posterioridad son borrados y no es
posible volver a acceder a ellos. Si al finalizar un programa PL/SQL no se especifica
que acción realizar sobre la transacción (ROLLBACK o COMMIT), el resultado de la
transacción dependerá de lo que realicemos con posterioridad a la finalización de la
transacción. Es por ello que una buena práctica en la creación de programas PL/SQL
consiste en la definición explícita de los COMMIT y ROLLBACK en aquellos puntos
que sean necesarios, sobre todo en los puntos de finalización de la transacción (final del
bloque, tratamiento de excepciones).


3.7.12 Trabajar con Cursores
PL/SQL utiliza dos tipos de cursores: implícitos y explícitos. PL/SQL declara un cursor
implícitamente para todas las sentencias DML de SQL, incluyendo consultas que
devuelven sólo un registro. Sin embargo, para consultas que devuelven más de un
registro, es necesario definir un cursor explícito o utilizar un bucle FOR para un cursor.

Cuando se trabaja con cursores explícitos, existen tres sentencias para controlar los
cursores: OPEN, FETCH y CLOSE. En primer lugar, y una vez declarado el cursor, es
necesario inicializarlo con la sentencia OPEN, con lo que se identifica ya el conjunto de
resultados. Posteriormente, se utiliza la sentencia FETCH para recuperar el primer
registro del resultado. Se puede ejecutar de forma repetitiva la sentencia FETCH para ir
pasando por el resto de registros que componen el conjunto de resultados, hasta que se
termina de completar un recorrido por todos los registros encontrados. Y una vez se han
procesado todos los registros, hay que liberar el cursor con la sentencia CLOSE.

La declaración de un cursor se hace siguiendo la sintaxis:
CURSOR cursor_name [(parameter[, parameter]...)]
[RETURN return_type] IS select_statement;

donde el return_type debe representar un registro de una base de datos, y los parámetros
son tipos de datos válidos SQL. Algunos ejemplos de declaraciones de cursores válidas:
DECLARE
CURSOR c1 IS SELECT empno, ename, job, sal FROM emp
WHERE sal > 2000;
CURSOR c2 RETURN dept%ROWTYPE IS
SELECT * FROM dept WHERE deptno = 10;

Un cursor puede aceptar parámetros, que pueden aparecer en la consulta asociada del
mismo modo que pueden aparecer constantes. Dicho de otro modo, es una forma de
pasar variables a las consultas SQL que ejecutan los cursores. Los parámetros sólo
pueden ser de entrada, se especifican con la palabra IN, y no sirven para devolver
resultados de la ejecución de una sentencia. La sintaxis de los parámetros es:
cursor_parameter_name [IN] datatype [{:= | DEFAULT} expression]

y un ejemplo de definición de cursores con parámetros sería:
DECLARE
CURSOR c1 (low INTEGER DEFAULT 0,
high INTEGER DEFAULT 99) IS SELECT ...

Cuando se abre un cursor (OPEN) se ejecuta la consulta y se identifica el conjunto de
resultados. Para los cursores declarados con la cláusula FOR UPDATE, además se
bloquean los registros recuperados. Un ejemplo de uso de OPEN es:
DECLARE
CURSOR c1 IS SELECT ename, job FROM emp WHERE sal < 3000;
...
BEGIN
OPEN c1;
...
END;


Si se desea pasar parámetros a un cursor, el momento de hacerlo es al utilizar la
sentencia OPEN, tal y como se muestra en este ejemplo:
DECLARE
emp_name emp.ename%TYPE;
salary emp.sal%TYPE;
CURSOR c1 (name VARCHAR2, salary NUMBER) IS SELECT ...
...
BEGIN
...
OPEN c1(emp_name, 3000);
OPEN c1('ATTLEY', 1500);
OPEN c1(emp_name, salary);

La sentencia FETCH sigue la siguiente estructura:
FETCH c1 INTO variable_1,variable_2,...,variable_n;

La sentencia FETCH, como ya hemos mencionado, debe ser utilizada dentro de un
bucle. Un ejemplo de uso de FETCH es el siguiente:
LOOP
FETCH c1 INTO my_record;
EXIT WHEN c1%NOTFOUND;
-- procesamiento del registro
END LOOP;

La sintaxis de cierre de cursor (CLOSE) sigue la siguiente estructura:
CLOSE cursor_name;

Los cursores implícitos se abren para procesar cualquier sentencia SQL no asociada con
un cursor explícito. Con los cursores implícitos no se pueden utilizar las sentencias
OPEN, FETCH y CLOSE.

Los cursores (variables) tienen 4 atributos que se pueden utilizar para tener un mayor
control sobre el procesamiento de las consultas dentro de los bucles. Dichos parámetros
son:

%FOUND. Atributo que contiene el valor NULL después de que se abre el cursor, pero
antes de realizar el primer FETCH. Después de cada FETCH (incluido el primero), el
atributo toma el valor TRUE si se encontró algún registro que satisfaga la consulta
definida para el cursor, o FALSE en caso contrario. Ejemplo de uso:
LOOP
FETCH c1 INTO my_ename, my_sal, my_hiredate;
IF c1%FOUND THEN -- fetch succeeded
...
ELSE -- fetch failed, so exit loop
EXIT;
END IF;
END LOOP;

%ISOPEN. Es un atributo que contiene el valor TRUE si el cursor está abierto, y en
caso contrario contiene el valor FALSE. Ejemplo de uso:
IF c1%ISOPEN THEN -- cursor is open


...
ELSE -- cursor is closed, so open it
OPEN c1;
END IF;

%NOTFOUND. Es un parámetro que es lo lógicamente opuesto a %FOUND. Sin
embargo, hay que tener cuidado con el uso de este atributo, puesto que si FETCH no se
ejecuta nunca de forma satisfactoria (no se encuentra ningún registro) su valor siempre
será NULL y no se saldrá nunca del bucle. Un ejemplo de uso es:
LOOP
FETCH c1 INTO my_ename, my_sal, my_hiredate;
...
END LOOP;

%ROWCOUNT. Es un atributo que, cuando el cursor está abierto, tiene valor 0, y a
medida que se van recuperando registros, va incrementando en 1 su valor. Se utiliza
para contar los registros recuperados en un bucle con FETCH. Un ejemplo de uso es:
LOOP
FETCH c1 INTO my_ename, my_deptno;
IF c1%ROWCOUNT > 10 THEN
...
END IF;
...
END LOOP;

Por último, vamos a ilustrar el uso de los cursores con algunos ejemplos.

Ejemplo 1: El programa utiliza un cursor para obtener los valores de tres campos (n1,
n2 y n3) de la tabla data_table, y guarda el resultado en tres variables locales del
programa. Posteriormente, el programa inserta en otra tabla (temp) una serie de datos
que han sido calculados en la información obtenida con el cursor para el procesamiento
de la consulta anterior. Obsérvese la finalización del programa con la cláusula
COMMIT, que valida todas las inserciones realizadas en la tabla temp de forma
conjunta, en lugar de hacer una validación una a una.
DECLARE
num1 data_table.n1%TYPE; -- Declare variables
num2 data_table.n2%TYPE; -- having same types as
num3 data_table.n3%TYPE; -- database columns
result temp.col1%TYPE;
CURSOR c1 IS
SELECT n1, n2, n3 FROM data_table WHERE exper_num = 1;
BEGIN
OPEN c1;
LOOP
FETCH c1 INTO num1, num2, num3;
result := num2/(num1 + num3);
INSERT INTO temp VALUES (result, NULL, NULL);
END LOOP;
CLOSE c1;
COMMIT;
END;


Ejemplo 2: Este programa comprueba todos los contenedores que contienen el item
número 5469, retirando sus contenidos hasta acumular un total de 1000 unidades.
DECLARE
CURSOR bin_cur(part_number NUMBER) IS
SELECT amt_in_bin FROM bins
WHERE part_num = part_number AND amt_in_bin > 0
ORDER BY bin_num
FOR UPDATE OF amt_in_bin;
bin_amt bins.amt_in_bin%TYPE;
total_so_far NUMBER(5) := 0;
amount_needed CONSTANT NUMBER(5) := 1000;
bins_looked_at NUMBER(3) := 0;
BEGIN
OPEN bin_cur(5469);
WHILE total_so_far < amount_needed LOOP
FETCH bin_cur INTO bin_amt;
EXIT WHEN bin_cur%NOTFOUND;
-- if we exit, there's not enough to fill the
order
bins_looked_at := bins_looked_at + 1;
IF total_so_far + bin_amt < amount_needed THEN
UPDATE bins SET amt_in_bin = 0
WHERE CURRENT OF bin_cur;
-- take everything in the bin
total_so_far := total_so_far + bin_amt;
ELSE -- we finally have enough
UPDATE bins SET amt_in_bin = amt_in_bin
- (amount_needed - total_so_far)
WHERE CURRENT OF bin_cur;
total_so_far := amount_needed;
END IF;
END LOOP;
CLOSE bin_cur;
INSERT INTO temp
VALUES (NULL, bins_looked_at, '<- bins looked at');
COMMIT;
END;

3.7.13 Subprogramas (Procedimientos y Funciones)
Los subprogramas son bloques PL/SQL que pueden aceptar parámetros y pueden ser
invocados desde cualquier bloque PL/SQL. Existen dos tipos de subprogramas:
procedimientos y funciones. Los procedimientos se utilizan para realizar ciertas
acciones, y las funciones se usan para computar valores.

Los subprogramas, igual que los bloques PL/SQL, tienen una parte declarativa, una
parte ejecutable, y una parte opcional de gestión de errores. Los subprogramas
proporcionan extensibilidad al PL/SQL. Permiten modularizar los programas de modo
que su desarrollo y posterior lectura resulten más cómodos e intuitivos. Además, el uso
de subprogramas permite reusabilidad y mantenibilidad de código, que de otra forma no
sería posible.


Los procedimientos tienen la siguiente sintaxis en PL/SQL:
PROCEDURE name [(parameter[, parameter, ...])] IS
[local declarations]
BEGIN
executable statements
[EXCEPTION
exception handlers]
END [name];

donde los parámetros se definen de la siguiente forma (IN indica parámetro de entrada,
OUT indica parámetro de salidad, IN OUT indica parámetro de entrada/salida):
parameter_name [IN | OUT [NOCOPY] | IN OUT [NOCOPY]] datatype_name
[{:= | DEFAULT} expression]

Hay que destacar que los tipos de datos de los parámetros no se pueden restringir. Por
ejemplo, no se puede definir un tipo de datos CHAR(5), sino que se debe definir un tipo
de datos CHAR.

Un ejemplo de procedimiento sería el siguiente:
PROCEDURE raise_salary (emp_id INTEGER, amount REAL) IS
current_salary REAL;
salary_missing EXCEPTION;
BEGIN
SELECT sal INTO current_salary FROM emp
WHERE empno = emp_id;
IF current_salary IS NULL THEN
RAISE salary_missing;
ELSE
UPDATE emp SET sal = sal + amount
WHERE empno = emp_id;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
INSERT INTO emp_audit VALUES (emp_id,'No such number');
WHEN salary_missing THEN
INSERT INTO emp_audit VALUES (emp_id,'Salary is null');
END raise_salary;

Las funciones tienen la siguiente sintaxis en PL/SQL:
FUNCTION name [(parameter[, parameter, ...])] RETURN datatype IS
[local declarations]
BEGIN
executable statements
[EXCEPTION
exception handlers]
END [name];

donde los parámetros, igual que en los procedimientos, se definen de la siguiente forma:
parameter_name [IN | OUT [NOCOPY] | IN OUT [NOCOPY]] datatype_name
[{:= | DEFAULT} expression]


Un ejemplo de función sería:
FUNCTION sal_ok (salary REAL, title REAL) RETURN BOOLEAN IS
min_sal REAL;
max_sal REAL;
BEGIN
SELECT losal, hisal INTO min_sal, max_sal
FROM sals
WHERE job = title;
RETURN (salary >= min_sal) AND (salary <= max_sal);
END sal_ok;

Tanto los procedimientos como las funciones se pueden declarar dentro de la sección de
declaración de un programa PL/SQL, pero al final de la sección, después de la
declaración del resto de items del programa. Es posible realizar una declaración previa
de los procedimientos sin su definición (para ser utilizada por el resto de procedimientos
que la necesiten), y declarar su definición con posterioridad. Por ejemplo:
DECLARE
PROCEDURE calc_rating ( ... ); -- forward declaration
...
/* Define subprograms in alphabetical order. */
PROCEDURE award_bonus ( ... ) IS
BEGIN
calc_rating( ... );
...
END;
PROCEDURE calc_rating ( ... ) IS
BEGIN
...
END;

Los subprogramas se pueden almacenar de forma permanente en la base de datos
utilizando la misma sintaxis que hemos definido, pero añadiendo la cláusula CREATE
antes de PROCEDURE o FUNCTION, y cambiando la palabra IS por AS. Por ejemplo:
CREATE PROCEDURE fire_employee (emp_id NUMBER) AS
BEGIN
DELETE FROM emp WHERE empno = emp_id;
END;

Tanto los procedimientos como las funciones permiten el polimorfismo, esto es, se
pueden definir varios subprogramas con el mismo nombre, pero con distinto número y/o
tipo de parámetros. Esto aporta enormes ventajas en el trabajo con subprogramas, pero
requiere especial atención por parte del programador para no cometer errores y/o
mantener subprogramas obsoletos o sin uso. Las funciones, además, pueden definirse de
forma recursiva.

3.7.14 Programas de ejemplo
A continuación se proporcionan una serie de programas de ejemplo que ayuden a
familiarizarse con el contexto y forma de trabajar de PL/SQL, así como para ayudar a
comprender la sintaxis del lenguaje y los bloques estructurales de los mismos, y las
sentencias de control, uso de cursores y ámbito de utilización de variables.


Programa 1:
DECLARE
x NUMBER := 100;
BEGIN
FOR i IN 1..10 LOOP
IF MOD(i,2) = 0 THEN -- i is even
INSERT INTO temp VALUES (i, x, 'i is even');
ELSE
INSERT INTO temp VALUES (i, x, 'i is odd');
END IF;
x := x + 100;
END LOOP;
COMMIT;
END;

Programa 2:
DECLARE
CURSOR c1 is
SELECT ename, empno, sal FROM emp ORDER BY sal DESC;
my_ename CHAR(10);
my_empno NUMBER(4);
my_sal NUMBER(7,2);
BEGIN
OPEN c1;
FOR i IN 1..5 LOOP
FETCH c1 INTO my_ename, my_empno, my_sal;
EXIT WHEN c1%NOTFOUND; /* in case the number requested */
/* is more than the total */
/* number of employees */
INSERT INTO temp VALUES (my_sal, my_empno, my_ename);
COMMIT;
END LOOP;
CLOSE c1;
END;

Programa 3:
DECLARE
x NUMBER := 0;
counter NUMBER := 0;
BEGIN
FOR i IN 1..4 LOOP
x := x + 1000;
counter := counter + 1;
INSERT INTO temp VALUES (x, counter, 'outer loop');
/* start an inner block */
DECLARE
x NUMBER := 0; -- this is a local version of x
BEGIN
FOR i IN 1..4 LOOP
x := x + 1; -- this increments the local x
counter := counter + 1;
INSERT INTO temp VALUES (x, counter, 'inner loop');
END LOOP;
END;
END LOOP;
COMMIT;
END;


Programa 4:
DECLARE
CURSOR c1 IS
SELECT account_id, oper_type, new_value FROM action
ORDER BY time_tag
FOR UPDATE OF status;
BEGIN
FOR acct IN c1 LOOP -- process each row one at a time

acct.oper_type := upper(acct.oper_type);

/*----------------------------------------*/
/* Process an UPDATE. If the account to */
/* be updated doesn't exist, create a new */
/* account. */
/*----------------------------------------*/
IF acct.oper_type = 'U' THEN
UPDATE accounts SET bal = acct.new_value
WHERE account_id = acct.account_id;

IF SQL%NOTFOUND THEN -- account didn't exist. Create it.
INSERT INTO accounts
VALUES (acct.account_id, acct.new_value);
UPDATE action SET status =
'Update: ID not found. Value inserted.'
WHERE CURRENT OF c1;
ELSE
UPDATE action SET status = 'Update: Success.'
END IF;

/*--------------------------------------------*/
/* Process an INSERT. If the account already */
/* exists, do an update of the account */
/* instead. */
/*--------------------------------------------*/
ELSIF acct.oper_type = 'I' THEN
BEGIN
INSERT INTO accounts
VALUES (acct.account_id, acct.new_value);
UPDATE action set status = 'Insert: Success.'
EXCEPTION
WHEN DUP_VAL_ON_INDEX THEN -- account already exists
UPDATE accounts SET bal = acct.new_value
'Insert: Acct exists. Updated instead.'
END;

/*--------------------------------------------*/
/* Process a DELETE. If the account doesn't */
/* exist, set the status field to say that */
/* the account wasn't found. */
/*--------------------------------------------*/
ELSIF acct.oper_type = 'D' THEN
DELETE FROM accounts


IF SQL%NOTFOUND THEN -- account didn't exist.
UPDATE action SET status = 'Delete: ID not found.'
ELSE
UPDATE action SET status = 'Delete: Success.'
END IF;

/*--------------------------------------------*/
/* The requested operation is invalid. */
/*--------------------------------------------*/
ELSE -- oper_type is invalid
'Invalid operation. No action taken.'

END IF;

END LOOP;
COMMIT;
END;


Lenguajes de consulta y definición de datos en bases de datos relacionales

Recommandé

Recommandé

Contenu connexe

Similaire à Lenguajes de consulta y definición de datos en bases de datos relacionales

Similaire à Lenguajes de consulta y definición de datos en bases de datos relacionales (20)

Plus de Luis Gonzales

Plus de Luis Gonzales (20)

Dernier

Dernier (20)

Lenguajes de consulta y definición de datos en bases de datos relacionales