Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Manual PL SQL Espanol PDF
Manual PL SQL Espanol PDF
PL/SQL I
VERSIÓN 1 JPV-99 1 / 67
PL/SQL I
INTRODUCCIÓN
VERSIÓN 1 JPV-99 2 / 67
PL/SQL I
CONTENIDO
2. EL BLOQUE PL/SQL
ZONA DE DECLARACIÓN: DECLARACIÓN DE VARIABLES Y
CONSTANTES
ZONA DE PROCESO
ZONA DE EXCEPCIONES
4. SENTENCIAS DE CONTROL
5. SENTENCIAS DE DML
6 CURSORES
MANEJO DE CURSORES
BUCLES SOBRE CURSORES
EJEMPLO DE CURSORES
7. REGISTROS Y TABLAS
REGISTROS PL/SQL
TABLAS EN PL/SQL
8. SENTENCIAS TRANSACCIONALES
9 CONTROL DE ERRORES
10 RESUMEN
11 EVALUACIÓN
VERSIÓN 1 JPV-99 3 / 67
PL/SQL I
OBJETIVOS
EXPECTATIVAS
• ··························································································································
························································································································
• ··························································································································
························································································································
• ··························································································································
························································································································
VERSIÓN 1 JPV-99 4 / 67
PL/SQL I
IMPORTANTE
• Procedimientos y funciones
Nos permite utilizar técnicas procedurales como bucles, control de flujo, tratamiento de
variables y control de errores en el procesamiento de las filas devueltas en una
SELECT.
NOTA
VERSIÓN 1 JPV-99 5 / 67
PL/SQL I
NOTA
Dispone de:
NOTA
VERSIÓN 1 JPV-99 6 / 67
PL/SQL I
2. EL BLOQUE PL/SQL
IMPORTANTE
• Sección declarativa.
• Sección de excepciones.
ESTRUCTURA:
[DECLARE]
Variable
VERSIÓN 1 JPV-99 7 / 67
PL/SQL I
BEGIN
[EXCEPTION]
Control de excepciones
NOTA
Las variables son utilizadas para guardar valores devueltos por una consulta o
almacenar cálculos intermedios.
VERSIÓN 1 JPV-99 8 / 67
PL/SQL I
Var1 number(59);
Var2 Var1%TYPE;
Var3 tabla.identificador%TYPE;
Se puede también declarar una fila variable cuyos campos tienen el mismo nombre y
tipo que las columnas de una tabla o fila recuperada de un cursor:
registro tabla%ROWTYPE
VERSIÓN 1 JPV-99 9 / 67
PL/SQL I
TIPOS DE DATOS.
Date - Fechas
NOTA
VERSIÓN 1 JPV-99 10 / 67
PL/SQL I
ZONA DE PROCESO
En esta zona es donde se escriben todas las sentencias ejecutables: sentencias DML,
asignaciones, manejo de cursores, bucles, etc.
Es importante recordar que todas las SELECT ejecutadas dentro de un bloque PL/SQL
llevan asociado un INTO.
Una SELECT que no devuelva datos o que devuelva más de uno provoca un ERROR,
saltando la ejecución directamente al EXCEPTION.
ASIGNACIÓN DE VALORES
Las dos formas que existen para asignar valores a variables de memoria, son:
xprom:=xtotal/xcant;
SELECT SUM(valor),
COUNT(valor)
INTO xtotal,xcant
FROM ventas
WHERE fecha=sysdate;
VERSIÓN 1 JPV-99 11 / 67
PL/SQL I
COMENTARIOS
ZONA DE EXCEPCIONES
DUP_VAL_ON_INDEX ORA–00001 –1
VERSIÓN 1 JPV-99 12 / 67
PL/SQL I
EJERCICIO
EJERCICIO Nº 1
• Definir una variable, y, del mismo tipo que el campo hiredate, de la tabla
EMP, de la base de datos DEMO.
VERSIÓN 1 JPV-99 13 / 67
PL/SQL I
EJERCICIO
EJERCICIO Nº 2
VERSIÓN 1 JPV-99 14 / 67
PL/SQL I
IMPORTANTE
♦ CHR Chr(x)
VERSIÓN 1 JPV-99 15 / 67
PL/SQL I
VERSIÓN 1 JPV-99 16 / 67
PL/SQL I
SQL> SELECT LPAD (‘Short String’, 20, ‘XY’) Cadena FROM dual;
SQL> SELECT REPLACE (‘This and That’, ’Th’, ’B’) Cadena FROM dual;
> 23de
VERSIÓN 1 JPV-99 17 / 67
PL/SQL I
> 11
FUNCIONES NUMÉRICAS
VERSIÓN 1 JPV-99 18 / 67
PL/SQL I
♦ LN LN (x)
VERSIÓN 1 JPV-99 19 / 67
PL/SQL I
> 15.7
> 17-DEC-80
FUNCIONES DE FECHA
VERSIÓN 1 JPV-99 20 / 67
PL/SQL I
♦ SYSDATE SYSDATE
FROM emp
> 17-JAN-1981
ADD_MONTHS(
LAST_DAY(hiredate),5),
FROM emp
> 28-FEB-1982
VERSIÓN 1 JPV-99 21 / 67
PL/SQL I
FUNCIONES DE CONVERSIÓN
CONVERSIONES IMPLÍCITAS
CONVERSIONES EXPLÍCITAS
VERSIÓN 1 JPV-99 22 / 67
PL/SQL I
'NLS_DATE_LANGUAGE = American')
FROM DUAL;
> 15/01/1989,11:00:00
FROM emp
FROM DUAL;
> -10000
VERSIÓN 1 JPV-99 23 / 67
PL/SQL I
FORMATOS NUMÉRICOS
, 9,999 comma
. 99.99 period
VERSIÓN 1 JPV-99 24 / 67
PL/SQL I
FORMATOS DE FECHA:
IYY, IY, I Last three, two or one digits of the ISO year
Y,YYY (Four Y's with comma) put a comma in the year (1,995)
YEAR, SYEAR Year spelled out (S prefixes BC dates with a minus sign)
RR Last two digits of year in another century (allows for year 2000)
BC, AD BC or AD indicator
MONTH Name of month spelled out (upper case - month is upper case)
VERSIÓN 1 JPV-99 25 / 67
PL/SQL I
MI Minute (0-59)
SS Second (0-60)
FUNCIONES DE GRUPO
VERSIÓN 1 JPV-99 26 / 67
PL/SQL I
OTRAS FUNCIONES
compara2, valor2…
predeterminado)
VERSIÓN 1 JPV-99 27 / 67
PL/SQL I
♦ USER USER
OPCIONES
VERSIÓN 1 JPV-99 28 / 67
PL/SQL I
>ENAME COMMISSION
---------- -----------------
ALLEN 300
WARD 500
MARTIN 1400
BLAKE NOT APPLICABLE
TURNER 0
JAMES NOT APPLICABLE
'PROCEDURE','R','FUNCTION','F'),TYPE,LINE;
VERSIÓN 1 JPV-99 29 / 67
PL/SQL I
PRÁCTICA
EJERCICIO Nº 3
-Crear una tabla empleado como copia de la tabla emp. El nuevo nombre será
emp + nº de usuario.
-Modificar los registros de la tabla creada de modo que en lugar del nombre del
empleado aparezca el nombre del empleado terminado en @ para aquellos
empleados llamados JONES cuyo curso es el el 2
EJERCICIO Nº 4
EJERCICIO Nº 5
VERSIÓN 1 JPV-99 30 / 67
PL/SQL I
4. SENTENCIAS DE CONTROL
SENTENCIA IF
ELSE sentencias_ejecutables; ]
END IF;
SQL> DECLARE
v_NumberSeats rooms.number_seats%TYPE;
v_Comment VARCHAR2(35);
BEGIN
/* Recibe el número de asientos de la sala identificada por ID 99999.
Almacena resultado en v_NumberSeats. */
SELECT number_seats
INTO v_NumberSeats
FROM rooms
WHERE room_id = 99999;
IF v_NumberSeats < 50 THEN
v_Comment := 'Fairly small';
ELSIF v_NumberSeats < 100 THEN
v_Comment := 'A little bigger';
ELSE
v_Comment := 'Lots of room';
VERSIÓN 1 JPV-99 31 / 67
PL/SQL I
END IF;
END;
/
BUCLE INFINITO:
LOOP
sentencias_ejecutables;
END LOOP;
SQL> DECLARE
ranking_level NUMBER(3) := 1;
BEGIN
IF max_rank_in >= 1
THEN
LOOP
set_rank (ranking_level);
ranking_level := ranking_level + 1;
EXIT WHEN ranking_level > max_rank_in;
END LOOP;
END IF;
END;
VERSIÓN 1 JPV-99 32 / 67
PL/SQL I
BUCLES CONDICIONALES:
WHILE condición
LOOP
sentencias_ejecutables;
END LOOP;
SQL> DECLARE
v_Counter BINARY_INTEGER := 1;
BEGIN
v_Counter := v_Counter + 1;
END LOOP;
END;
VERSIÓN 1 JPV-99 33 / 67
PL/SQL I
BUCLES NUMÉRICOS:
LOOP
sentencias_ejecutables;
END LOOP;
SQL> DECLARE
v_Counter NUMBER := 7;
BEGIN
VALUES (v_Counter);
VALUES (v_Counter);
END LOOP;
VERSIÓN 1 JPV-99 34 / 67
PL/SQL I
VALUES (v_Counter);
END;
EJERCICIO
EJERCICIO 7
• Introducir una fila por cada día del mes actual de tal forma que el resultado
final sea algo parecido a esto:
DÍAS
1
2
3
4
5
...
29
30
• Realizar el ejercicio utilizando for...loop , loop...exit y while.
VERSIÓN 1 JPV-99 35 / 67
PL/SQL I
5. SENTENCIAS DE DML
IMPORTANTE
♦ Oracle abre un cursor implícito por cada sentencia SQL que tenga que
procesar.
VERSIÓN 1 JPV-99 36 / 67
PL/SQL I
if SQL%NOTFOUND then
end if;
EJERCICIO
EJERCICIO 8
• Utilizar la tabla DEPT y un registro para recuperar los datos de dicha tabla.
VERSIÓN 1 JPV-99 37 / 67
PL/SQL I
EJERCICIO
EJERCICIO 9
• Crear un bloque PL/SQL que modifique la tabla EMP de tal forma aquellos
empleados cuyo número de empleado sea –1 pasen a tener como job
‘CLERK’.
VERSIÓN 1 JPV-99 38 / 67
PL/SQL I
6. CURSORES
El conjunto de filas resultantes de una consulta con la sentencia SELECT, puede estar
compuesto por ninguna, una o varias filas, dependiendo de la condición que define la
consulta.
IMPORTANTE
♦ Declaración:
♦ Para recuperar los datos de un cursor primero hay que abrirlo (OPEN),
luego leerlo (FETCH), y por último cerrarlo (CLOSE).
VERSIÓN 1 JPV-99 39 / 67
PL/SQL I
MANEJO DE CURSORES
• Abre el cursor.
Se realiza la lectura y se ejecutan las sentencias del bucle hasta que no haya
más filas.
VERSIÓN 1 JPV-99 40 / 67
PL/SQL I
• Cierra el cursor.
LOOP
sentencias_ejecutables;
END LOOP;
EJEMPLO DE CURSORES
Nombre:CVENTAS.
VERSIÓN 1 JPV-99 41 / 67
PL/SQL I
BEGIN
IS SELECT articulo,valor
FROM ventas
WHERE fecha=cfecha
xarticulo ventas.articulo%TYPE;
xvalor ventas.valor%TYPE;
BEGIN
OPEN cventas(xfecha);
(xfecha,xarticulo,xvalor);
COMMIT;
END LOOP;
CLOSE cventas;
END;
END;
VERSIÓN 1 JPV-99 42 / 67
PL/SQL I
Para llamar al procedimiento ventas5 en una fecha dada, se puede escribir, por
ejemplo:
ventas5(to_date('15/11/95','DD/MM/YY')
ventas5(sysdate).
DECLARE cursor
xarticulo ventas.articulo%TYPE;
OPEN cventas(xfecha);
VERSIÓN 1 JPV-99 43 / 67
PL/SQL I
Lee la siguiente fila de datos del cursor cventas y pasa los datos de la consulta
a las variables xarticulo y xvalor.
Garantiza la salida del ciclo antes de la última repetición, en caso que para una
fecha dada se hayan efectuado menos de 5 ventas, ya que en esta situación la
consulta del cursor devuelve menos de 5 filas.
VALUES(xfecha,xarticulo,xvalor);
COMMIT;
END LOOP;
CLOSE cventas;
EJERCICIO
EJERCICIO 10
VERSIÓN 1 JPV-99 44 / 67
PL/SQL I
EJERCICIO
EJERCICIO 11
• Crear una tabla de totales por departamentos con dos campos: uno para los
números de departamento y otro numérico para meter los totales por
departamento.
EJERCICIO
EJERCICIO 12
• Contar cuántos empleados hay de cada tipo de job. Utilizar un cursor para
obtener los distintos tipos de trabajo, y otro cursor parametrizado en el cual
se le pasa el trabajo recuperado con el cursor anterior.
VERSIÓN 1 JPV-99 45 / 67
PL/SQL I
7. REGISTROS Y TABLAS
REGISTROS PL/SQL
IMPORTANTE
.....
Una vez declarado un registro es necesario definir una variable de este tipo.
Se puede asignar un registro a otro del mismo tipo o sus campo individualmente, con
la condición de que ambos sean del mismo tipo.
VERSIÓN 1 JPV-99 46 / 67
PL/SQL I
EJEMPLO:
DECLARE
Field1 NUMBER,
Field2 VARCHAR2(5));
Field1 NUMBER,
Field2 VARCHAR2(5));
v_Rec1 t_Rec1Type;
v_Rec2 t_Rec2Type;
BEGIN
v_Rec1 := v_Rec2;
/* Estos campos, son del mismo tipo, por los que la asignación sería
legal. */
v_Rec1.Field1 := v_Rec2.Field1;
v_Rec2.Field2 := v_Rec2.Field2;
END;
VERSIÓN 1 JPV-99 47 / 67
PL/SQL I
TABLAS EN PL/SQL
IMPORTANTE
♦ Una tabla PL/SQL es similar a una tabla de base de datos pero como si
tuviera dos columnas una de ellas es el índice y la otra el valor.
VERSIÓN 1 JPV-99 48 / 67
PL/SQL I
INDEX BY BINARY_INTEGER;
EJEMPLO
DECLARE
TYPE t_LastNameTable IS TABLE OF students.last_name%TYPE
INDEX BY BINARY_INTEGER;
v_LastNames t_LastNameTable;
v_Index BINARY_INTEGER;
BEGIN
Inserta filas en la tabla.
VERSIÓN 1 JPV-99 49 / 67
PL/SQL I
v_LastNames(43) := 'Mason';
v_LastNames(50) := 'Junebug';
v_LastNames(47) := 'Taller';
-- Asigna 43 a v_Index.
v_Index := v_LastNames.FIRST;
-- Asigna 50 a v_Index.
v_Index := v_LastNames.LAST;
END;
/
TABLAS DE REGISTROS
EJEMPLO
DECLARE
TYPE t_StudentTable IS TABLE OF students%ROWTYPE
INDEX BY BINARY_INTEGER;
/* Cada elemento de v_Students es un registro */
v_Students t_StudentTable;
BEGIN
/* Obtiene el registro record con id = 10,001 and y lo almacena en
v_Students(10001) */
SELECT *
INTO v_Students(10001)
FROM students
WHERE id = 10001;
v_Students(10001).first_name := 'Larry';
DBMS_OUTPUT.PUT_LINE(v_Students(10001).first_name);
END;
/
VERSIÓN 1 JPV-99 50 / 67
PL/SQL I
EJERCICIO
EJERCICIO 13
• Recuperar los datos con un registro y mostrar por pantalla cada una de las
filas recuperadas en el cursor de la siguiente manera:
SMITH
------>CLERK 800
JAMES
------>CLERK 950
ADAMS
------>CLERK 1100
PEPE
------>CLERK 1300 750
PEDRO PEREZ
------>CLERK
Pedro Perez
------>CLERK
VERSIÓN 1 JPV-99 51 / 67
PL/SQL I
EJERCICIO
EJERCICIO 14
VERSIÓN 1 JPV-99 52 / 67
PL/SQL I
EJERCICIO
EJERCICIO 15
Empno - number(4),
sal – number(7, 2) ,
VERSIÓN 1 JPV-99 53 / 67
PL/SQL I
8. SENTENCIAS TRANSACCIONALES
IMPORTANTE
• Savepoint:
Marcas que pone el usuario durante la transacción para deshacer los cambios
por partes en vez de deshacer toda la transacción.
SAVEPOINT <nombre_del_punto_salvaguarda>;
• Commit:
COMMIT [WORK];
• Rollback:
VERSIÓN 1 JPV-99 54 / 67
PL/SQL I
EJEMPLO
DECLARE
v_NumIterations NUMBER;
BEGIN
-- Loop from 1 to 500, inserting these values into temp_table.
-- Commit every 50 rows.
FOR v_LoopCounter IN 1..500 LOOP
INSERT INTO temp_table (num_col) VALUES (v_LoopCounter);
v_NumIterations := v_NumIterations + 1;
IF v_NumIterations = 50 THEN
COMMIT;
v_NumIterations := 0;
END IF;
END LOOP;
END;
/
PRÁCTICA
EJERCICIO 16
Codigo - number(4),
Mensaje – varchar2(80)
b) Actualizar los vendedores con una comisión mayor que 350$ con un
incremento del 15% de su salario. Si la operación afecta a más de
tres empleados, deshacer la transacción, en cualquier otro caso
validar la transacción. Introducir en la tabla TEMP la operación que
se ha realizado.
VERSIÓN 1 JPV-99 55 / 67
PL/SQL I
PRÁCTICA
EJERCICIO 17
• Dentro del mismos bloque PL/SQL actualizar los empleados con una
comisión mayor de 350 $ con un incremento del 15% de su salario. Si la
operación afecta a más de tres empleados, deshacer la transacción, en
cualquier otro caso validar dicha transacción.
VERSIÓN 1 JPV-99 56 / 67
PL/SQL I
9. CONTROL DE ERRORES
IMPORTANTE
THEN SENTENCIAS;
NOTA
TIPOS DE EXCEPCIONES:
EXCEPCIONES PREDEFINIDAS:
NO_DATA_FOUND,
TOO_MANY_ROWS,
DUP_VAL_ON_INDEX....
VERSIÓN 1 JPV-99 57 / 67
PL/SQL I
Mediante:
NOTA
EJECUCIÓN DE EXCEPCIONES
RAISE <nombre_excepción>;
VERSIÓN 1 JPV-99 58 / 67
PL/SQL I
FUNCIONES
La función SQLCODE nos devuelve el número de error producido. Sólo tiene valor
cuando ocurre un error ORACLE
La función SQLERRM nos devuelve el mensaje del error del valor actual del
SQLCODE.
NOTA
Su sintaxis es:
EJEMPLOS Y TRATAMIENTO
VERSIÓN 1 JPV-99 59 / 67
PL/SQL I
REM
REM
DECLARE
err_msg VARCHAR2(100);
BEGIN
LOOP
THEN
BEGIN
EXCEPTION
WHEN DUP_VAL_ON_INDEX
THEN
NULL;
END;
END IF;
END LOOP;
END;
VERSIÓN 1 JPV-99 60 / 67
PL/SQL I
DECLARE
pe_ratio NUMBER(3,1);
BEGIN
INTO pe_ratio
FROM stocks
COMMIT;
COMMIT;
...
ROLLBACK;
VERSIÓN 1 JPV-99 61 / 67
PL/SQL I
DECLARE
insufficient_privileges EXCEPTION;
------------------------------------------------------
-------------------------------------------------------
BEGIN
...
EXCEPTION
Maneja el error
...
END;
DECLARE
...
null_salary EXCEPTION;
VERSIÓN 1 JPV-99 62 / 67
PL/SQL I
BEGIN
...
raise_salary(:emp_number, :amount);
EXCEPTION
...
END;
PRÁCTICA
EJERCICIO 18
• Crear un bloque PL/SQL con una única sentencia SELECT sobre la tabla
EMPLEADOS, de tal forma que va a ir recuperando el salario del empleado
del trabajo que se introduzca por teclado.
VERSIÓN 1 JPV-99 63 / 67
PL/SQL I
10. RESUMEN
• Procedimientos y funciones
Oracle abre un cursor implícito por cada sentencia SQL que tenga que
procesar.
VERSIÓN 1 JPV-99 64 / 67
PL/SQL I
Declaración de un cursor:
Para recuperar los datos de un cursor primero hay que abrirlo (OPEN),
luego leerlo (FETCH), y por último cerrarlo (CLOSE).
Una tabla PL/SQL es similar a una tabla de base de datos pero como si
tuviera dos columnas una de ellas es el índice y la otra el valor.
VERSIÓN 1 JPV-99 65 / 67
PL/SQL I
11. EVALUACIÓN
a) Siempre
c) Nunca
a) En la zona declarativa
declare a number:=2;
resultado varchar2(20);
begin
select decode(a,3,'Menor',4,'Siguiente',5,'Mayor','Otro') into resultado
from dual;
dbms_output.put_line(resultado);
end;
/
a) No compilaría porque en la declaración no puede asignarse
una variable a un número
b) Mayor
c) Otro
VERSIÓN 1 JPV-99 66 / 67
PL/SQL I
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
...............................................................................................................
VERSIÓN 1 JPV-99 67 / 67
PL/SQL II
PL/SQL II
VERSIÓN 1 JPV-99 1 / 50
PL/SQL II
INTRODUCCIÓN
PL/SQL sólo puede contener órdenes DML y no DDL. Sin embargo esta
restricción se supera a partir de la versión 2.1 con el paquete
DBMS_SQL. Este paquete implementa código PL/SQL y SQL dinámico,
al que se llama desde otros bloques PL/SQL.
VERSIÓN 1 JPV-99 2 / 50
PL/SQL II
CONTENIDO:
1. PROCEDIMIENTOS Y FUNCIONES
PROCEDIMIENTOS
FUNCIONES
SUBPROGRAMAS LOCALES.
PAQUETES (PACKAGES)
3. DISPARADORES (TRIGGERS)
CREACIÓN DE DISPARADORES
4. PL/SQL DINÁMICO
CONCEPTO
MÉTODOS DE IMPLEMENTACIÓN
5. EJERCICIO DE DESARROLLO
6. RESUMEN
7. EVALUACIÓN
VERSIÓN 1 JPV-99 3 / 50
PL/SQL II
OBJETIVOS
EXPECTATIVAS
• ··························································································································
························································································································
• ··························································································································
························································································································
• ··························································································································
························································································································
VERSIÓN 1 JPV-99 4 / 50
PL/SQL II
1. PROCEDIMIENTOS Y FUNCIONES
IMPORTANTE
NOTA
VERSIÓN 1 JPV-99 5 / 50
PL/SQL II
PROCEDIMIENTOS
CREACIÓN DE PROCEDIMIENTOS
Bloque PL/SQL
Su estructura es semejante a:
tmpVar NUMBER;
/******************************************************************************
NAME: PROCEDIMIENTO
PURPOSE: To calculate the desired information.
REVISIONS:
Ver Date Author Description
--------- ---------- --------------- ------------------------------------
1.0 10/09/99 1. Created this procedure.
******************************************************************************/
BEGIN
tmpVar := 0;
EXCEPTION
Null;
Null;
END PROCEDIMIENTO;
/
VERSIÓN 1 JPV-99 6 / 50
PL/SQL II
NOTA
• Un procedimiento termina con END o con END seguido del nombre del
procedimiento.
NOTA
VERSIÓN 1 JPV-99 7 / 50
PL/SQL II
BORRADO
EJECUCIÓN
IMPORTANTE
NOTA
VERSIÓN 1 JPV-99 8 / 50
PL/SQL II
PRÁCTICA
EJERCICIO 1
EJERCICIO 2
VERSIÓN 1 JPV-99 9 / 50
PL/SQL II
FUNCIONES
CREACIÓN DE FUNCIONES
RETURN tipo_dato IS O AS
Bloque PL/SQL
Su estructura es semejante a:
tmpVar NUMBER;
/******************************************************************************
NAME: FUNCION
PURPOSE: To calculate the desired information.
REVISIONS:
Ver Date Author Description
--------- ---------- --------------- ------------------------------------
1.0 10/09/99 1. Created this function.
******************************************************************************/
BEGIN
tmpVar := 0;
EXCEPTION
Null;
Null;
RETURN tmpVar;
END FUNCION;
VERSIÓN 1 JPV-99 10 / 50
PL/SQL II
NOTA
Los argumentos OUT o IN OUT son válidos dentro de las funciones pero se
usan raramente.
BORRADO
EJECUCIÓN
IMPORTANTE
VERSIÓN 1 JPV-99 11 / 50
PL/SQL II
• Una función se puede invocar desde una sentencia SELECT, WHERE, HAVING,
cláusula VALUES de un INSERT y SET de un UPDATE.
• Debe de ser una función de fila única (devuelven un único valor). No pueden ser ni
registros ni tablas.
• Los tipos de datos: BOOLEAN, RECORD o TABLE no están permitidos (no son
tipo SQL).
NOTA
VERSIÓN 1 JPV-99 12 / 50
PL/SQL II
SUBPROGRAMAS LOCALES.
IMPORTANTE
PRÁCTICA
EJERCICIO 3
• Crear una función que nos permita realizar una consulta del salario del
empleado de la tabla EMP que se le pasa como parámetro desde SQL* (se
le pasa el número del empleado). Si la consulta ha sido satisfactoria la
función devuelve un SI, en caso contrario devuelve un NO.
VERSIÓN 1 JPV-99 13 / 50
PL/SQL II
EJERCICIO 4
• Utilizar una sentencia SELECT sobre la tabla EMP que nos permita ver los
campos empno, ename y el salario de los empleados. Si el empleado tiene
una salario múltiplo de 5 y mayor de 1500 mostrar su salario multiplicado por
15, en caso contrario su salario permanece invariable.
EJERCICIO 5
• Utilizar una SELECT para extraer de la tabla EMP cada uno de los
empleados y su máximo jefe.
EJERCICIO 6
VERSIÓN 1 JPV-99 14 / 50
PL/SQL II
• DATABASE LINK
• FUNCTION
• INDEX
• PACKAGE
• PACKAGE BODY
• PROCEDURE
• SEQUENCE
• SYNONYM
• TABLE
• TRIGGER
• VIEW
• FUNCTION
• PACKAGE
• PACKAGE BODY
• PROCEDURE
VERSIÓN 1 JPV-99 15 / 50
PL/SQL II
IMPORTANTE
SET SERVEROUTPUT ON
DBMS_OUTPUT.PUT (Texto);
VERSIÓN 1 JPV-99 16 / 50
PL/SQL II
DBMS_OUTPUT.NEW_LINE;
DBMS_OUTPUT.PUT_LINE (varchar2)
DBMS_OUTPUT.PUT_LINE (number)
DBMS_OUTPUT.PUT_LINE (date)
NOTA
VERSIÓN 1 JPV-99 17 / 50
PL/SQL II
NOTA
NOTA
Para que no nos dé un error debido a que el buffer es muy pequeño, conviene
inicializarlo mediante el comando:
VERSIÓN 1 JPV-99 18 / 50
PL/SQL II
IMPORTANTE
Estructura de un paquete:
Variable Pública
PÚBLICA
Zona de Especificación
Variable Privada
PRIVADA
Cuerpo del paquete
VERSIÓN 1 JPV-99 19 / 50
PL/SQL II
CREACIÓN DE PAQUETES
Declaración variable
Declaración cursor
Declaración excepción
Declaración procedimiento
Declaración función
END Nombre_paquete
Declaración variable
Declaración cursor
Declaración excepción
Código de la función
END Nombre_paquete
VERSIÓN 1 JPV-99 20 / 50
PL/SQL II
EXEC[UTE] Nombre_paquete.Nombre_función ó
Nombre_procedimiento
NOTA
NOMBRE_PAQUETE.NOMBRE_OBJETO
• Siempre es posible declarar una variable en un bloque PL/SQL del mismo tipo que
uno que figure dentro del package:
DECLARE
V_hist ClassPackage.t_lista;
NOTA
Dentro del cuerpo del paquete se puede hacer referencia a los objetos sin
necesidad del "."
VERSIÓN 1 JPV-99 21 / 50
PL/SQL II
DECLARE
FUNCTION value_ok (date_in IN DATE)
RETURN BOOLEAN IS
BEGIN
RETURN date_in <= SYSDATE; Date Version
END;
NOTA
VERSIÓN 1 JPV-99 22 / 50
PL/SQL II
select
'alter '||
' '||
object_name||
' compile'||
from
user_objects
where
status = 'INVALID'
• No se puede utilizar una función que está dentro de un paquete en una sentencia
SQL. Es necesario indicar el nivel de depuración.
VERSIÓN 1 JPV-99 23 / 50
PL/SQL II
END PAQUETE;
VERSIÓN 1 JPV-99 24 / 50
PL/SQL II
TmpVar NUMBER;
BEGIN
tmpVar := 0;
EXCEPTION
Null;
Null;
RETURN tmpVar;
END MyFuncName;
TmpVar NUMBER;
BEGIN
tmpVar := 0;
EXCEPTION
Null;
Null;
END MyProcName;
END PAQUETE;
VERSIÓN 1 JPV-99 25 / 50
PL/SQL II
PRÁCTICA
EJERCICIO 7
• Crear un paquete con los siguientes elementos: una tabla para almacenar
registros con los campos nombre, salario, un procedimiento
pr_insertar(nombre, salario) y un índice.
EJERCICIO 8
VERSIÓN 1 JPV-99 26 / 50
PL/SQL II
EJERCICIO 9
• Crear un paquete con tres funciones que se van a llamar (las tres)
fu_recupera.
EJERCICIO 10
• Realizar una consulta en SQL* sobre la tabla EMP de forma que extraiga los
empleados cuya comisión sea mayor que el valor devuelto por la función
fu_media_comision.
VERSIÓN 1 JPV-99 27 / 50
PL/SQL II
DISPARADORES (TRIGGERS)
IMPORTANTE
El aviso automático a otros programas de que hay que llevar a cabo una
determinada acción, cuando se realiza un cambio en la tabla.
Tipos de disparadores:
VERSIÓN 1 JPV-99 28 / 50
PL/SQL II
Disparadores de fila: Se activan una vez por cada fila afectada por la orden que
provocó el disparo.
Clasificación:
*BEFORE
Según el momento en el que salta el disparador
* AFTER
* INSERT
Según el tipo de operación que provoca su actuación * UPDATE
* DELETE
* Sentencia
Según las veces que se ejecuta el cuerpo del disparador
* Fila
NOTA
VERSIÓN 1 JPV-99 29 / 50
PL/SQL II
CREACIÓN DE DISPARADORES
DISPARADORES DE SENTENCIA
BLOQUE PL/SQL
DISPARADORES DE FILA
VERSIÓN 1 JPV-99 30 / 50
PL/SQL II
NOTA
Aunque no surga un error de compilación, hay que tener en cuenta que :OLD no
está definido para las órdenes INSERT, así como no lo estará :NEW para el
DELETE.
NOTA
A pesar de que :NEW y :OLD sean tratados sintácticamente como registros del
tipo tabladisparo%Rowtype, en realidad no son registros (por tanto no se
pueden asignar como registros completos); sino que son variables de
acoplamiento.
ACTIVACIÓN DE DISPARADORES
VERSIÓN 1 JPV-99 31 / 50
PL/SQL II
IMPORTANTE
♦ Una tabla mutante es una tabla que está modificándose actualmente por
una orden DML (INSERT, UPDATE, DELETE).
Supongamos un trigger for each row que se dispara cuando se modifiquen datos de
una tabla. El trigger a su vez realiza una modificación sobre la misma tabla. Esto
provoca que la tabla quede mutante por la incosistencia de la información en ese
instante y da un error por pantalla.
VERSIÓN 1 JPV-99 32 / 50
PL/SQL II
NOTA
Si una operación INSERT afecta a una única fila, entonces los disparadores de
fila previo y posterior por dicha fila no tratarán a la tabla como mutante.
tmpVar NUMBER;
BEGIN
tmpVar := 0;
:NEW.SequenceColumn := tmpVar;
:NEW.CreatedDate := Sysdate;
VERSIÓN 1 JPV-99 33 / 50
PL/SQL II
:NEW.CreatedUser := User;
EXCEPTION
Null;
END DISPARADOR;
PRÁCTICA
EJERCICIO 11
EJERCICIO 12
VERSIÓN 1 JPV-99 34 / 50
PL/SQL II
EJERCICIO 13
EJERCICIO 14
EJERCICIO 15
VERSIÓN 1 JPV-99 35 / 50
PL/SQL II
EJERCICIO 16
• Sustituir el trigger de fila por dos, uno antes de modificar (for each row) y
otro after (de sentencia) y un paquete que solucione el error de la tabla
mutante.
VERSIÓN 1 JPV-99 36 / 50
PL/SQL II
4. PL/SQL DINÁMICO
CONCEPTO
IMPORTANTE
Las órdenes SQL Dinámicas tienen muy pocas restricciones, porque si se desea, la
orden completa SQl se puede determinar en el momento de la ejecución, en lugar de
en la compilación.
NOTA
Desventajas:
VERSIÓN 1 JPV-99 37 / 50
PL/SQL II
• Procedure DBMS_SQL.BIND_VARIABLE
• Procedure DBMS_SQL.DEFINE_COLUMN
columna_variable IN <column_datatype>);
• FUNCTION DBMS_SQL.FETCH_ROWS
VERSIÓN 1 JPV-99 38 / 50
PL/SQL II
• PROCEDURE DBMS_SQL.COLUMN_VALUE
• PROCEDURE DBMS_SQL.CLOSE_CURSOR
Cierra el cursor.
MÉTODOS DE IMPLEMENTACIÓN
IMPORTANTE
• Ejecución de consultas
VERSIÓN 1 JPV-99 39 / 50
PL/SQL II
Estructura de la orden:
VERSIÓN 1 JPV-99 40 / 50
PL/SQL II
Estructura de la orden:
VERSIÓN 1 JPV-99 41 / 50
PL/SQL II
EJECUCIÓN DE CONSULTAS
Estructura de la orden:
VERSIÓN 1 JPV-99 42 / 50
PL/SQL II
VERSIÓN 1 JPV-99 43 / 50
PL/SQL II
NOTA
Procurar siempre cerrar todos los cursores una vez ejecutada la sentencia,
incluso a través de las excepciones.
NOTA
El símbolo de doble guión hace que se considere como comentario todo lo que
sigue, hasta encontrar un carácter de avance de linea. Sin embargo, dado que
el bloque completo se encuentra en una cadena, todo el resto del bloque sería
considerado un comentario.
VERSIÓN 1 JPV-99 44 / 50
PL/SQL II
PRÁCTICA
EJERCICIO 17
P Primary Key
U Unique Key
R Foreign Key
C Check constraint
EJERCICIO 18
EJERCICIO 19
VERSIÓN 1 JPV-99 45 / 50
PL/SQL II
5. EJERCICIO DE DESARROLLO
2.- Mediante un cursor Modificar dicha tabla y subir el sueldo a los empleados
que pertenezcan al departamento SALES
3.- Crear una función que devuelva la media de sueldo de los empleados que
tengan el mismo puesto (JOB) pasándole como parámetro en formato texto
dicho cargo.
4.- Crear un disparador tal que cuando modifiquemos el sueldo del presidente,
se encargue de recalcular el resto de los sueldos de todos los empleados en el
mismo porcentaje.
5.- Crear un procedimiento que actualice la fecha HIREDATE al primer día del
siguiente mes del día de la semana que coincida con la fecha anterior.
6.- Crear un procedimiento dinámico que borre todos los objetos de la base de
datos del tipo que nosotros le pasemos como parámetro del usuario que está
conectado.
VERSIÓN 1 JPV-99 46 / 50
PL/SQL II
6. RESUMEN
VERSIÓN 1 JPV-99 47 / 50
PL/SQL II
Una tabla mutante es una tabla que está modificándose actualmente por
una orden DML (INSERT, UPDATE, DELETE).
Ejecución de consultas
VERSIÓN 1 JPV-99 48 / 50
PL/SQL II
7. EVALUACIÓN
a) START procedimiento
b) EXEC procedimiento
c) RUN procedimiento
VERSIÓN 1 JPV-99 49 / 50
PL/SQL II
4. Un disparador ..
a) Permite argumentos
a) Una tabla que se altera cuando dos usuarios modifican los datos de
una tabla a la vez.
a) NO_DATA_FOUND
b) TOO_MANY_ROWS
c) VALUE_ERROR
VERSIÓN 1 JPV-99 50 / 50
ANEXOS A CURSO PL/SQL
VERSIÓN 1 JPV- 99 1 / 49
ANEXOS A CURSO PL/SQL
ANEXO 1: SQL*PLUS
La herramienta que nos proporciona ORACLE para interactuar con la base de datos se llama
SQL*Plus. Básicamente, es un intérprete SQL con algunas opciones de edición y formateo de
resultados.
Conceptos previos antes de conectarse a SQL*Plus:
• Usuario/Clave
Para poder acceder a una base de datos gestionada por ORACLE debemos ser
un usuario autorizado de la misma y conocer la palabra clave, password, asociada
al usuario.
1 CONEXIÓN
$ sqlplus usuario/passwd
$ sqlplus usuario/passwd@servicio
Otra circunstancia que hay que tener en cuenta a la hora de conectarnos a SQL*Plus es el
modo establecido por el DBA para la autentificación del usuario de la base de datos. La
primera posibilidad es que recaiga sobre el SGBD Oracle la autentificación de los usuarios,
por lo que tendremos que darle nuestro nombre de usuario y la palabra de paso. Pero existe
la posibilidad de que el SGBD Oracle deje en manos del Sistema Operativo esta
responsabilidad. Así, no será necesario demostrarle al SGBD Oracle quién somos ya que el
SO se ha encargado previamente de comprobar que todo es correcto. En este segundo caso,
el comando de conexión con SQL*Plus debe omitir el nombre de usuario y la palabra clave,
pero manteniendo el resto de esta manera:
$ sqlplus /@servicio
VERSIÓN 1 JPV- 99 2 / 49
ANEXOS A CURSO PL/SQL
Una vez que hemos conseguido entrar en SQL*Plus nos presenta el prompt y espera la
insercción de sentencias SQL. Todas las sentencias deben acabar con un ';'. Una sentencia
puede continuar en varias líneas, que SQL*Plus va numerando. Si queremos anular la
sentencia actual podemos hacerlo colocando un '.' como único carácter en una línea. Si
queremos volver a ejecutar la última sentencia se puede hacer con el comando '/'. Si
queremos ejecutar las sentencias que almacena un fichero .sql podemos hacerlo
anteponiendo el símbolo '@' al nombre del fichero.
Para cerrar la sesión vale con teclear 'exit'.
2 POSIBILIDADES DE EDICIÓN
SQL*Plus almacena en un buffer la última sentencia SQL introducida. El buffer mantiene sólo
una sentencia cada vez, y si se introduce una nueva sentencia se sobreescribe sobre la
anterior.
La sentencia en el buffer puede ser recuperada para ejecutarla de nuevo con los comandos:
• RUN que visualiza la sentencia en el buffer antes de ejecutarla;
Al contenido del buffer también se puede acceder desde el editor del Sistema Operativo. Así,
el buffer podrá ser manipulado con las posibilidades del editor con el que estemos
VERSIÓN 1 JPV- 99 3 / 49
ANEXOS A CURSO PL/SQL
SQL> define_editor=vi
SQL> edit
3 UTILIZACIÓN DE FICHEROS
VERSIÓN 1 JPV- 99 4 / 49
ANEXOS A CURSO PL/SQL
• START: Ejecuta el fichero del sistema operativo que se indique, admite hasta nueve
parámetros posicionales indicados en la línea de comandos (los parámetros se definen
como un número entero comprendidos entre 1 y 9).
START nombre_fichero [parámetro1, parámetro2, …]
• DESCRIBE o DESC: Este comando da una breve descripción de las características de
cada columna de la tabla indicada. Por cada columna se muestra el nombre, si se
admiten o no valores nulos, tipos de datos, ancho de columna.
DESCRIBE nombre_tabla
• HOST: Pasa al servidor para su ejecución la orden escrita a continuación y ejecuta la
orden sin que el usuario abandone su sesión de SQL*Plus.
HOST orden
• SPOOL: Envía los resultados de una orden SQL a un fichero para imprimirlas
posteriormente.
SPOOL [fichero|OFF|OUT] ON
• EDIT: Llama al editor activo del sistema operativo.
• Variables de sustitución: Es una variable definida por el usuario.
&nombre_variable
• Cuando SQL*Plus encuentra una variable de sustitución en un comando lo ejecuta
como si contuviese el valor de esa variable, y si no se ha definido su valor, pregunta el
valor que se le desea dar. Si se desea qué sólo pregunte una vez por su valor en una
variable que aparece varias veces se la marcará con &&.
5 FICHEROS DE COMANDOS
LÍNEAS DE COMENTARIOS
VERSIÓN 1 JPV- 99 5 / 49
ANEXOS A CURSO PL/SQL
LÍNEAS DE EJECUCIÓN
Constan de una única barra inclinada, "/", y se introducen a continuación de cada sentencia
SQL indicando su ejecución.
Sustituyen al punto y coma, ";" al final de las sentencias SQL.
SQL*Plus aporta una serie de posibilidades al lenguaje SQL que le acerca un poco mas a lo
que entendemos como un lenguaje de programación.
Se pueden definir constantes y variables, capturar datos del teclado, introducir parámetros en
la llamada de un archivo de comandos, y alguna cosa más.
Variables de Usuario
Se pueden definir Variables de usuario con el comando DEFINE
DEFINE Variable = valor
Variables de Sustitución
Las variables de sustitución son un nombre de variable de usuario con el símbolo & delante.
Cuando SQL*Plus detecta una variable de sustitución en un comando, ejecuta el comando
tomando el valor de la variable.
Esto se puede ver en el ejemplo, donde preguntamos por los empleados que son analistas:
VERSIÓN 1 JPV- 99 6 / 49
ANEXOS A CURSO PL/SQL
NOMBRE OFICIO
---------- -----------
Sastre Analista
Recio Analista
Si se desea que SQL*Plus pregunte por el valor de la variable al usuario sólo la primera vez
que se encuentra con ella, se colocará "&&" delante de la variable de usuario.
También se pueden utilizar hasta nueve parámetros en la línea de comandos cuando se
llama a la ejecución de un archivo de comandos.
En el archivo de comandos nos referiremos a los parámetros con las variables &1, &2, ... ,&9
que se corresponden posicionalmente con ellos.
Desde el archivo de comandos se puede hacer referencia a los parámetros cualquier número
de veces y en cualquier orden.
VERSIÓN 1 JPV- 99 7 / 49
ANEXOS A CURSO PL/SQL
Otros Comandos
Los siguientes comandos también se pueden incluir en un archivo de comandos:
• CONNECT: para conectarse como otro usuario.
• HELP: para obtener ayuda en línea.
• EXIT: para dejar SQL*PLus y salir al Sistema Operativo.
• DESCRIBE ó DESC: para obtener información sobre la estructura de una tabla.
• HOST o !: para ejecutar un comando del Sistema Operativo.
6 GENERACIÓN DE INFORMES
Con SQL*Plus podemos dar forma a los resultados de las consultas para producir un informe.
Podremos:
• Cambiar las cabeceras de las columnas.
• Dar forma a las columnas de tipo number, varchar2, date y long.
• Copiar y listar atributos de presentación de las columnas.
• Suprimir valores duplicados e introducir espacios para mejorar la presentación.
• Realizar y mostrar cálculos (totales, medias, mínimos, máximos, etc.).
• Definir las dimensiones de las páginas.
• Ubicar títulos en la cabecera y pie de las páginas.
• Introducir la fecha o el número de página en los títulos.
Básicamente, el formato con el que se van a presentar los resultados de las cosultas
dependen de unos parámetros y de unos comandos.
PARÁMETROS
• SET LINESIZE: pone el número máximo de caracteres por línea. Por defecto vale 80 y
el máximo es 999.
• SET PAGESIZE: pone el número de filas de la salida antes de empezar una nueva
página. Por defecto es 25. Incluye el título y las líneas de pausa.
• SET HEADING [ON | OFF]: Activa/desactiva la utilización de encabezados de
columnas. Por defecto está activado.
VERSIÓN 1 JPV- 99 8 / 49
ANEXOS A CURSO PL/SQL
• SET NULL texto: Indica la cadena de caracteres que hay que colocar en sustitución de
los valores NULL. Por defecto es "".
• SET ECHO [ON | OFF]: Activa/desactiva la visualización de los comandos que
SQL*Plus ejecuta según van siendo tratados. Por defecto está desactivada.
• SET FEEDBACK [ n | ON | OFF]: Muestra el número de registros recuperados en
cada consulta cuando se recuperan n o más registros. ON se pueden considerar como
n=1, y OFF como n=0.
• SET VERIFY [ON | OFF]: Controla la salida de confirmación para los valores de las
variables de sustitución. Por defecto está activado.
COMANDOS
VERSIÓN 1 JPV- 99 9 / 49
ANEXOS A CURSO PL/SQL
La sentencia SELECT recupera datos de una base de datos y los devuelve en forma de
resultados de la consulta. Conviene diferenciar de forma clara la cláusula y la sentencia
SELECT. Mientras que la cláusula solamente específica los columnas que se quieren listar la
sentencia engloba a toda la sintaxis que tiene como objetivo recuperar ciertos datos.
La cláusula SELECT específica los ítems que se desea recuperar, que puede ser.
• Nombre de columna.
• Una constante.
• Expresiones que calcula SQL.
El especificador * como sustituto de la lista de ítems separados por comas indica todas las
columnas. ORACLE no permite combinaciones con * y expresiones pero en otros productos
esto es posible.
La cláusula FROM indica la tabla o las tablas de las que se toman los datos solicitados. A
dichas tablas se las llama tablas fuentes de las consultas.
La cláusula WHERE dice a SQL que incluya solo ciertas filas de datos en los resultados de la
consulta.
La cláusula GROUP BY específica la consulta sumaria. En vez de producir una fila de
resultados por cada fila de datos de la base de datos, una consulta sumaria agrupa todas las
filas similares y luego produce una fila sumaria de resultados para cada grupo.
La cláusula ORDER BY ordena los resultados de la consulta en base a los datos de uno o
más ítems. Si se omite, los resultados de la consulta no aparecen ordenados.
VERSIÓN 1 JPV- 99 10 / 49
ANEXOS A CURSO PL/SQL
La cláusula HAVING dice a SQL que incluya sólo ciertos grupos producidos por la cláusula
GROUP BY en los resultados de las consultas.
La estructura tabular hace que los datos sean tablas al igual que las consultas.
Se entiende por columna calculada la que se genera a partir de otras columnas o constantes
por medio de expresiones de SQL.
Precediendo a la lista de ítems en la cláusula SELECT puede aparecer el especificador
DISTINCT que indica la eliminación de las filas duplicadas.
La cláusula SELECT va seguida de una lista de campos a recuperar. Estos campos pueden
pertenecer a una/varias tablas y/o vistas. Las posibilidades de declaración de estos campos
se recogen en el siguiente esquema:
<columna> ["<alias_columna>']
<tabla>.<columna>["<alias~columna>"]
<alias_tabla>.<columna>["<alias_columna>"]
<usuario>.<tabla>.<columna>["<alias-columna>"]
donde:
<columna> Nombre de la columna de la que queremos obtener valores.
<tabla> Nombre de la tabla a la que pertenece la columna.
<alias_tabla> Alias dado a la tabla.
<usuario> Nombre del usuario de Base de Datos al que pertenece la tabla.
<alias columna> Alias de la columna.
Además de una lista de campos simple, la lista de campos SELECT se puede "ampliar'
introduciendo funciones u "operadores". Pasamos a exponer la lista de funciones permitidas
así como los operadores. En general, las funciones permitidas son funciones columna y el
operador al que nos referimos es DISTINCT.
FUNCIONES COLUMNA
Una función columna toma a una columna como argumento y produce un único dato que
sumariza la columna. SQL ofrece seis funciones de columna diferentes:
• SUM() calcula el total de una columna.
VERSIÓN 1 JPV- 99 11 / 49
ANEXOS A CURSO PL/SQL
CLAUSULA FROM
La cláusula FROM permite especificar de dónde vamos a obtener los diferentes resultados.
En la lista FROM podremos incluir nombres de tablas, sinónimos de las mismas o nombres
de vistas En general, la lista que prosigue a FROM es <tabla>[<alias_tabla>] donde:
<tabla> Nombre de la tabla, sinónimo o view
<alias tabla> Alias dado a la tabla; sinónimo o vista por el cual podemos referirnos a la
misma en la sentencia SQL
TEST DE COMPARACIÓN
Compara el valor de una expresión con otra; para lo cual utiliza los siguientes símbolos de
comparación:
=, <, >, <=, >= y <> (también != y ¬=)
Si la comparación es cierta, el test produce como resultado TRUE y por tanto la fila será
incluida. Si por el contrario es falsa producirá un FALSE y será excluida al igual que si alguno
de los términos de la comparación es NULL.
VERSIÓN 1 JPV- 99 12 / 49
ANEXOS A CURSO PL/SQL
Si alguna de las columnas ha sido definida a la hora de crear la tabla como clave primaria
esto implica que no puede haber valores duplicados en dicha columna con lo cual esta servirá
para diferenciar unívocamente cada fila.
El test de rangos comprueba si un valor de dato se encuentra entre las dos expresiones
especificadas. Between incluye los puntos extremos del rango.
PERTENENCIA A UN CONJUNTO
SQL> SELECT *
2 FROM emp
3 WHERE job IN ( 'ANALYST', 'MANAGER');
Compara la expresión con otra obtenida partir de comodines, el patrón. Se utiliza el % como
carácter comodín para indicar el patrón “ cualquier cadena de caracteres” y el carácter _ como
patrón “ cualquier carácter simple” . Devuelve NULL si la expresión es NULL.
VERSIÓN 1 JPV- 99 13 / 49
ANEXOS A CURSO PL/SQL
2 FROM emp
3 WHERE ename LIKE 'J%';
SQL> SELECT ename
2 FROM emp
3 WHERE ename LIKE '_A%';
Dado que los caracteres _ y % tienen significados especiales, para hacer referencia a ellos
literalmente se puede definir para cada LIKE un carácter de escape añadiendo al final la
cláusula ESCAPE 'char'. Cuando en la expresión aparece el carácter char el carácter que le
precede se considera de forma literal.
Las condiciones de búsqueda simples se pueden combinar con OR, AND y NOT originando lo
que se llaman condiciones de búsqueda compuestas.
SQL> SELECT *
2 FROM cities
3 WHERE population<200000
4 AND state = ‘CA’;
SQL> SELECT *
2 FROM cities
VERSIÓN 1 JPV- 99 14 / 49
ANEXOS A CURSO PL/SQL
Por defecto ordena las filas seleccionadas en orden ascendente considerando el orden léxico
- gráfico que genera la lista de ítems. Con DESC este orden se hace descendente y con ASC
ascendente.
Cuando se quiere ordenar utilizando alguna columna no propia de la tabla sino que se ha
generado a través de una expresión en la cláusula SELECT esta se puede indicar a través de
la posición que ocupa en la lista de Items de la cláusula SELECT.
Una consulta que incluya la cláusula GROUP BY se denomina consulta agrupada, ya que
agrupa los datos de las tablas fuente y produce una única fila sumaria por cada grupo de filas.
Los ítems indicados en la cláusula GROUP BY se denominan ítems o columnas de
agrupación de la consulta, ya que ellas son las que determinan como se dividen las filas en
grupos. Los grupos se forman con todas aquellas filas que tienen los mismos valores en las
columnas de agrupación.
VERSIÓN 1 JPV- 99 15 / 49
ANEXOS A CURSO PL/SQL
VERSIÓN 1 JPV- 99 16 / 49
ANEXOS A CURSO PL/SQL
Si en una sentencia SELECT se tiene una cláusula HAVING sin una cláusula GROUP BY se
considera que todas las filas forman un único grupo rechazando o aceptándole en su
totalidad.
Esta es una característica específica del SQL proporcionado por ORACLE. Permite la
recuperación jerárquica de filas siguiendo una estructura tipo árbol. Las cláusulas asociadas a
este tipo de recuperación de datos son CONNECT BY...START WITH... y van siempre a
continuación de la cláusula WHERE.
<selección_sin_ORDER_BY>
UNION|INTERSECT|MINUS
<seleccion sin ORDER_BY>
ORDER BY <predicado>.
VERSIÓN 1 JPV- 99 17 / 49
ANEXOS A CURSO PL/SQL
UNION
Se pueden reunir varias sentencias select con el fin de seleccionar las filas que cada una de
las sentencias considera. Esto se hace gracias al comando UNION.
sentencia SELECT 1
UNION
sentencia SELECT 2
UNION
...
sentencia SELECT n
INTERSECT
sentencia SELECT 1
INTERSECT
sentencia SELECT 2
INTERSECT
VERSIÓN 1 JPV- 99 18 / 49
ANEXOS A CURSO PL/SQL
...
sentencia SELECT n
MINUS
sentencia SELECT 1
MINUS
sentencia SELECT 2
MINUS
...
sentencia SELECT n
Este tipo de combinación de sentencias SELECT devuelve aquellas filas que están en el
primer conjunto (datos obtenidos y vía la primera sentencia SELECT) pero no en el segundo.
Las filas duplicadas del primer conjunto se reducirán a una fila única antes de que empiece la
comparación con el otro conjunto.
Se llama componer tablas (join) al proceso de formar parejas de filas que se caracterizan por
tener común el contenido de las columnas relacionadas. La tabla resultante se llama
composición.
WHERE columnal=columna2
VERSIÓN 1 JPV- 99 19 / 49
ANEXOS A CURSO PL/SQL
SQL no requiere que las columnas de emparejamiento sean incluidas en los resultados de
una consulta multitabla.
Dado que puede haber nombres de columnas iguales aunque en tablas diferentes es
recomendable para evitar ambigüedades el uso de columnas cualificadas.
Se pueden establecer también relaciones entre columnas de una misma tabla de la misma
forma que se establecen entre tablas distintas. Para ello SQL utiliza la estrategia de tabla
duplicada o sea duplica la tabla original y lo establece como si se tratara de tablas distintas.
La palabra que precede al nombre de las tablas en la cláusula FROM es el ALIAS de dicha
tabla utilizado para diferenciarla de su copia que obviamente tendría si no es por el ALIAS
tendría el mismo nombre. Si no se utiliza el ALIAS no es necesario repetir columnas en el
FROM.
VERSIÓN 1 JPV- 99 20 / 49
ANEXOS A CURSO PL/SQL
Cuando la relación se establece por un valor NULL la fila o filas resultantes se desprecian. A
este tipo de emparejamiento se llama externo. Para forzar el emparejamiento de NULL se
utiliza el símbolo *=* en la cláusula WHERE. También se pueden utilizar los seis símbolos de
comparación en lugar del =. Hay que destacar que esta no es una especificación ANSI/ISO
ya que el estándar no trata este caso.
ORACLE utiliza (+) detrás de las columnas que se emparejan.
SUBCONSULTAS.
La característica de subconsulta de SQL permite utilizar los resultados de una consulta como
parte de otra. Esta característica hace que a SQL se le considere un lenguaje estructurado.
Hay consultas en SQL que no se pueden expresar sino es utilizando una subconsulta.
Una subconsulta es simplemente una consulta que aparece dentro del WHERE o HAVING de
otra sentencia SQL encerrada entre paréntesis.
Las restricciones que deben verificar las subconsultas son:
• Una subconsulta debe producir una única columna de datos como resultado. Por lo
cual la cláusula SELECT de la subconsulta debe de tener un único ítem.
• Una subconsulta no debe incluir la cláusula ORDER BY.
• Una subconsulta no puede estar integrarada por UNION.
Una subconsulta forma parte siempre de una condición de búsqueda en la cláusula WHERE
o HAVING. SQL ofrece estas condiciones de búsqueda en subconsultas.
Es una forrna modificada de test de comparación simple. Compara el valor de una expresión
con el valor producido por una subconsulta, y devuelve un resultado TRUE si la comparación
es cierta. La subconsulta debe de producir un valor único en caso contrarío SQL informa del
error. Si la subconsulta no devuelve ningún valor o produce un NULL, el test de comparación
devuelve NULL.
VERSIÓN 1 JPV- 99 21 / 49
ANEXOS A CURSO PL/SQL
El test de comparación subconsulta ofrece los mismos seis operadores de comparación (=, <,
>, <=, >=, <>).
Compara un único valor de datos con una columna de valores producida por una subconsulta
y devuelve un resultado TRUE si el valor coincide con uno de los valores de la columna.
Utiliza el operador IN.
TEST DE EXISTENCIA.
El test de existencia (EXISTS o NOT EXISTS) comprueba si una subconsulta produce alguna
fila de resultados o no.
TESTS CUALIFICADOS
EL TEST ANY
Se utiliza conjuntamente con los seis operadores de comparación para comparar un único
valor de test con una columna de valores producidos por una subconsulta. Para efectuar la
comparación se utiliza el operador de comparación especificado. Si alguna de las
comparaciones individuales produce un resultado TRUE, el test ANY devuelve un resultado
TRUE.
SQL> SELECT *
VERSIÓN 1 JPV- 99 22 / 49
ANEXOS A CURSO PL/SQL
2 FROM cities
3 WHERE population < ANY ( SELECT population
4 FROM cities
5 WHERE state = ‘CA’);
Sí la subconsulta produce una columna vacía de resultados el test ANY devuelve FALSE. Si
el test de comparación no es TRUE para ningún valor de datos en la columna pero es NULL
para uno o más de los valores, entonces la condición de búsqueda ANY devuelve NULL.
EL TEST ALL
La sintaxis es igual que el test ANY aunque la palabra clave utilizada es ALL. Si todas las
comparaciones individuales dan como resultado TRUE el test da como resultado TRUE.
SQL> SELECT *
2 FROM cities
3 WHERE population < ALL ( SELECT population
4 FROM cities
5 WHERE state = ‘TX’);
Si la subconsulta produce una columna vacía de resultados el test ALL devueIve TRUE. Si el
test de comparación no es FALSE para ningún valor de datos en la columna, pero es NULL
para uno o más de ellos, entonces la condición de búsqueda ALL devuelve NULL.
ANIDAMIENTO DE SUBCONSULTAS
Se pueden anidar subconsultas dentro de subconsultas sin ningún tipo de restricción salvo en
numero de niveles de anidamiento de límite el fabricante del producto SQL, el inconveniente
de su utilización radica en el excesivo tiempo necesario para realizarlas.
SQL> SELECT *
2 FROM customer
3 WHERE city NOT IN (SELECT city
4 FROM cities
5 WHERE population < ANY ( SELECT c.population
6 FROM cities c, usa u
7 WHERE c.state = u.state
8 AND u.data > 10000000));
VERSIÓN 1 JPV- 99 23 / 49
ANEXOS A CURSO PL/SQL
SUBCONSULTAS CORRELACIONADAS
Conceptualmente, SQL efectúa una subconsulta una y otra vez, una por cada fila de la
consulta principal. Algunos productos detectan esta circunstancia optimizando así el tiempo
de este tipo de consultas.
1. Si la sentencia es una UNION de sentencias select, aplicar los pasos 2 hasta 7 a cada
una de las sentencias, para generar sus resultados de consulta individuales.
2. Forma el producto de las tablas indicadas en la cláusula FROM. Si la cláusula FROM
designa una única tabla, el producto es esa tabla.
3. Si hay una cláusula WHERE, aplicar su condición de búsqueda a cada fila de la tabla
producto, reteniendo aquellas filas para las cuales la condición de búsqueda es TRUE (y
descartando aquellas para las cuales es FALSE o NULL). Si la cláusula WHERE contiene
una subconsulta, la subcosulta se efectúa por cada fila conforme es examinada.
4. Si hay una cláusula GROUP BY, disponer las filas restantes de la tabla producto en
grupos de filas, de modo que las filas de cada grupo tengan valores identicos en todas las
columnas de agrupación.
5. Si hay una cláusula HAVING, aplicar su condición de búsqueda a cada grupo de filas,
reteniendo aquellos grupos para los cuales la condición de búsqueda es TRUE (y
descartando aquellas para las cuales es FALSE o NULL). Si la cláusula HAVING contiene
una subconsulta, la subconsulta se efectúa para cada grupo de filas conforme es
examinada.
6. Para cada fila (o grupo de filas) restante, calcula el valor de cada elemento en la lista de
selección para producir una única fila de resultados. Para una referencia de columna
simple, utilizar el valor de la columna en la fila (o grupo de filas) actual. Para una función
de columna, utilizar como argumento el grupo de filas actual si se especifico GROUP BY;
en caso contrario, utilizar el conjunto entero de filas.
7. Si hubiera SELECT DISTINCT, eliminar las filas duplicadas de los resultados que se
hubieran producido.
8. Si la sentencia es una UNION de sentencias SELECT, mezclar los resultados de consulta
para las sentencias individuales en una única tabla de resultados. Eliminar las filas
duplicadas a menos que se haya especificado UNION ALL.
9. Si hay una cláusula ORDER BY, ordenar los resultados de la consulta según se haya
especificado.
Las filas generadas por este procedimiento forman los resultados de la consulta.
VERSIÓN 1 JPV- 99 24 / 49
ANEXOS A CURSO PL/SQL
Donde nombre-de-tabla especifica la tabla que recibe la nueva fila, a continuación (entre
paréntesis) se especifica una lista de nombres de colurnna de esa tabla, y después tras la
palabra VALUES los valores que se dan a cada una de esas columnas, en el mismo orden
que la lista de nombres de columnas.
Por supuesto los valores de los datos tras la cláusula VALUES deben ser válidos según el
tipo de datos de la columna que les corresponde.
Como podemos apreciar no es necesario asignar valores a todas las columnas de la nueva
fila, cuando SQL inserta una nueva fila de datos en una tabla, automáticamente asigna un
valor NULL a cualquier columna cuyo nombre falte de la lista de columnas especificada.
SQL permite omitir la lista de columnas de la sentencia INSERT, entonces SQL genera
automáticamente una lista formada por todas las columnas de la tabla, en secuencia de
izquierda a derecha (es la misma secuencia de columnas que la generada por un SELECT *).
Este tipo de actualizaciones se realizan habitualmente en aplicaciones diarias y suelen
hacerse mediante un programa de formularios, no obstante el formato de la sentencia
INSERT utilizando SQL interactivo o programado es la misma.
VERSIÓN 1 JPV- 99 25 / 49
ANEXOS A CURSO PL/SQL
Nota: SQL requiere que las filas sean tratadas como conjuntos en operaciones de inserción,
supresión y actualización, con lo que no existe la noción de insertar la fila 'al comienzo', 'al
final' o 'entre dos filas' de la tabla, después de ejecutar la sentencia INSERT la nueva fila
simplemente forma parte del conjunto de la tabla.
Ahora INSERT añade múltiples filas de datos a la tabla destino, los valores de datos para las
nuevas filas no son especificados explícitamente dentro del texto de la sentencia, sino que la
fuente de las nuevas filas es una consulta de base de datos especificada en la sentencia. Así
pues los nuevos datos se obtienen de la propia base de datos.
VERSIÓN 1 JPV- 99 26 / 49
ANEXOS A CURSO PL/SQL
Los datos a insertar en una base de datos son frecuentemente extraídos de otro sistema
informático o recolectados de otros lugares y almacenados en archivos secuenciales. Para
cargar los datos en una tabla, se podría escribir un programa que leyera cada registro del
archivo y utilizara la sentencia INSERT de una fila para añadir la fila a la tabla. Sin embargo,
el recargo de hacer que el RDBMS ejecute repetidamente sentencias INSERT de una fila
puede ser bastante alto, por esta razón todos los productos RDBMS comerciales incluyen una
capacidad de carga masiva que carga los datos desde un archivo a una tabla a alta
velocidad.
Nota: El estándar SQL ANSI/ISO no considera esta función, y suele ser suministrada como
un programa de utilidad autónomo, en lugar de formar parte del lenguaje SQL.
La cláusula FROM especifica la tabla destino que contiene las filas, la cláusula WHERE
especifica que filas de la tabla van a ser suprimidas.
Las condiciones de búsqueda que pueden especificarse en la cláusula WHERE de la
sentencia DELETE son las mismas disponibles en la cláusula WHERE de la sentencia
SELECT.
Conceptualmente SQL aplica la cláusula WHERE a cada una de las filas de la tabla
especificada, suprimiendo aquellas para las cuales la condición de búsqueda produce un
resultado TRUE.
Supongamos que queremos suprimir de nuestra tabla de libros el libro "El péndulo de
Foucault", cuya signatura es 10234 para ello hacemos:
VERSIÓN 1 JPV- 99 27 / 49
ANEXOS A CURSO PL/SQL
WHERE edad>80);
En el ejemplo suprimimos de la tabla de LIBROS las filas correspondientes a libros cuyo autor
tiene más de 8O años.
Las subconsultas pueden anidarse unas sobre otras y pueden contener referencias externas
a la tabla destino de la sentencia DELETE, con la única limitación (en una sentencia
DELETE) de que la tabla destino no puede aparecer en la cláusula FROM de una
subconsulta ni en ninguna de sus subconsultas anidadas.
UPDATE nombre-de-tabla
SET nombre-de-columna = expresión,
...
WHERE condición~de~busqueda
O bien:
UPDATE nombre-tabla
SET nombre-columna = (consulta),
...
WHERE condición-de-busqueda
UPDATE libros
SET precio = 1 .12 * precio;
WHERE EDITORIAL = 'Acme Editorial'
VERSIÓN 1 JPV- 99 28 / 49
ANEXOS A CURSO PL/SQL
UPDATE oficinas
SET cuota = 40000.00, ventas = cuota
WHERE cuota < 40000.00;
Aquí WHERE selecciona sólo aquellas OFICINAS cuya columna CUOTA tenía un valor
menor de 40000 antes de la sentencia UPDATE y la columna VENTAS toma el valor de la
columna CUOTA también antes del UPDATE.
La cláusula WHERE en la sentencia UPDATE es opcional, si se omite entonces se actualizan
todas las filas de la tabla destino.
Al igual que para la sentencia DELETE, en UPDATE también se pueden usar subconsultas,
que permiten seleccionar filas a actualizar en base a información contenida en otras tablas.
Las limitaciones de las subconsultas son las mismas que para los DELETES.
UPDATE clientes
SET rep_clie = 106
WHERE rep_clie IN (SELECT num_empl
FROM repventas
WHERE ventas < (0.8 * cuota));
VERSIÓN 1 JPV- 99 29 / 49
ANEXOS A CURSO PL/SQL
SINTAXIS GENERAL.
El nombre de la tabla debe ser único al igual que el nombre de la columna dentro de la tabla
(puede ser igual al nombre de una columna que pertenece a otra tabla).
Opcionalmente puede añadirse:
• NOT NULL: impide que existan valores nulos (NULL) dentro de la columna. Si se omite,
se permiten NULL.
• DEFAULT: especifica un valor por omisión para la columna.
VERSIÓN 1 JPV- 99 30 / 49
ANEXOS A CURSO PL/SQL
PRIMARY KEY: define la clave primaria. Sirve como identificador único para cada fila de la
tabla. Especifica la/s columna/s que forman la clave primaria de la tabla. Se exige que los
valores de la clave primaria para cada fila sean únicos y no nulos (NOT NULL para la/s
columna/s de la clave primaria).
FOREIGN KEY: define la clave foránea de la tabla. Específica la relación que crea con otra
tabla de la base de datos. Especifica:
• columnas dentro de la tabla que forman dicha clave.
• la tabla padre que es referenciada por la clave (hijo).
• nombre opcional para la relación. Este nombre cuando se produce un error.
• una regla de supresión opcional para la relación (RESTRICT, CASCADE o SET
NULL). Si no se especifica esta regla de supresión se utiliza la regla RESTRICT.
El RDBMS se asegura de que la clave foránea y la clave primaria de la tabla referenciada
concuerdan en número de columnas y tipo de dato.
VERSIÓN 1 JPV- 99 31 / 49
ANEXOS A CURSO PL/SQL
RESTRICCIONES DE UNICIDAD
VERSIÓN 1 JPV- 99 32 / 49
ANEXOS A CURSO PL/SQL
DROP borra la tabla de la base de datos, su definición y todos sus contenidos. Todo esto se
pierde y no hay forma de recuperarlo.
La nueva columna se añade al final de la tabla. El RDBMS asume un valor NULL para la
columna recién añadida en todas las filas existentes en la tabla. Puede ponerse NOT NULL
WITH DEFAULT con lo que el RDBMS pone el valor de defecto especificado. Todos estos
cambios se realizan cuando se intenta visualizar, no inmediatamente.
VERSIÓN 1 JPV- 99 33 / 49
ANEXOS A CURSO PL/SQL
No se puede suprimir una columna con ALTER. Los pasos que hay que dar son:
1. descargar todos los datos de la tabla.
2. utilizar la sentencia DROP TABLE cara borrar la definición de la tabla.
3. utilizar la sentencia CREATE TABLE para redefinir la tabla sin la columna no
deseada.
4. volver a cargar todos los datos que fueron anteriormente descargados.
Existen programas para cargar y descargar datos que facilitan esta labor de supresión.
Para ello la relación que se crea entre la tabla padre e hijo debe tener un nombre.
OTRAS MODIFICACIONES.
VERSIÓN 1 JPV- 99 34 / 49
ANEXOS A CURSO PL/SQL
Una vista es una tabla virtual en la base de datos cuyos contenidos están definidos por una
consulta. De cara al usuario aparece igual que una tabla real, con un conjunto de columnas
designadas y filas de datos. A diferencia de una tabla real, una vista no existe en la base de
datos como un conjunto almacenado de valores. La vista esta formada por un conjunto de
tablas fuente de las cuales se selecciona un conjunto de columnas (o todas).
Una vez definida la vista, se puede utilizar en una sentencia SELECT, lo mismo que en una
tabla real. En algunas vistas también se puede utilizar las sentencias INSERT, DELETE y
UPDATE para modificar datos a través de ella, corno si fuera una tabla real. Por tanto, a
todos los efectos prácticos, se puede utilizar como si fuera una tabla real.
Cuando el RDBMS se encuentra con la referencia de una vista en una sentencia, determina
la definición de la misma y luego traduce la petición que referencia a la vista a una petición
equivalente con respecto a las tablas fuentes de la vista y lleva a cabo la petición. Para vistas
muy complejas, define la vista y la almacena en una tabla temporal. Sobre ella realiza las
peticiones borrándola cuando ya no es necesaria.
Ventajas de las vistas
• Seguridad: cada usuario esta autorizado para acceder a una serie de vistas.
• Simplicidad en la consulta: se puede eliminar consultas multitabla.
VERSIÓN 1 JPV- 99 35 / 49
ANEXOS A CURSO PL/SQL
a) Vistas horizontales
Una vista horizontal divide horizontalmente la tabla fuente para crear la vista. Todas las
columnas de la tabla fuente participan en la vista, pero solo algunas de sus filas son visibles a
través de la vista.
La vista se deriva de una única tabla fuente. WHERE determina qué filas van a formar parte
de la vista.
b) Vistas verticales
Una vista vertical divide la tabla fuente verticalmente para crear la vista. Todas las filas de la
tabla fuente participan en la vista, pero solo algunas de sus columnas son visibles a través de
ella.
VERSIÓN 1 JPV- 99 36 / 49
ANEXOS A CURSO PL/SQL
La vista se deriva de una única tabla fuente. SELECT determina que columnas van a
tomar parte de la vista.
d) Vistas agrupadas
Una vista agrupada es aquella en la que los datos visibles a través de ella son el resultado de
una consulta agrupada. Las vistas agrupadas toman una columna de la tabla, le aplican una
función de grupo, producen una fila resultado y se le asigna a un nombre de columna.
VERSIÓN 1 JPV- 99 37 / 49
ANEXOS A CURSO PL/SQL
Las vistas agrupadas funcionan como vistas de solo lectura, pueden participar en consultas,
pero no en actualizaciones.
e) Vistas compuestas
Una vista compuesta extrae sus datos de dos o tres tablas diferentes y presentan los
resultados de la consulta como única tabla virtual.
Donde:
col 1, col 2, ...nombres de las columnas de la vista.
cola, colb ... nombres de las columnas de las tablas especificadas por FROM.
Sobre esta nueva vista puede hacerse todo tipo de consultas y accesos a datos.
En una vista se puede insertar una fila de datos, suprimirla y actualizarla. Cualquier tipo de
modificación realizada en la vista implica una modificación en la/s tabla/s original/es.
Bajo el estándar ANSI/ISO una vista puede ser actualizada si la consulta que define satisface
las siguientes restricciones.
VERSIÓN 1 JPV- 99 38 / 49
ANEXOS A CURSO PL/SQL
Existe una opción de comprobación de actualización de vistas: CHECK OPTION. Esta opción
se especifica en la sentencia CREATE VIEW de la siguiente forma:
Con esta opción, se comprueba automáticamente cada operación INSERT y UPDATE sobre
la vista para asegurarse de que las filas resultantes satisfagan el criterio de búsqueda de la
definición de vista. Si una fila insertada o modificada no satisface la condición, la sentencia
INSERT o UPDATE fallaría y la operación no se llevaría a cabo. Con esto se consigue la
integridad de las bases de datos, pues si se omitiera esta opción y se intentara actualizar una
fila en la vista que no satisficiera el criterio de búsqueda, el RDBMS la actualizaría en la/s
tabla/s fuente pero no en la vista. Si posteriormente se realiza una consulta dicha fila no
aparecería en la vista. Con la opción de comprobación se impide que modificaciones
efectuadas a través de la vista afecten a datos que no son accesibles al usuario en primera
instancia.
VERSIÓN 1 JPV- 99 39 / 49
ANEXOS A CURSO PL/SQL
donde <nombre de la view> es el nombre dado por nosotros a esta VIEW en la sentencia de
creación CREATE VIEW.
Un sinónimo es un nombre definido para representar el nombre de una tabla que pertenece a
otro usuario. Si se tiene permiso para acceder a la tabla de otro usuario se debe poner
usuario.nombre de la tabla.nombre de la columna
Para simplificar esto se puede sustituir usuario.nombre de la tabla por un sinónimo:
PUBLIC especifica que el sinónimo puede ser empleado por todos los usuarios de la base de
datos. Si se omite PUBLIC, por defecto el sinónimo solo es accesible a su creador.
VERSIÓN 1 JPV- 99 40 / 49
ANEXOS A CURSO PL/SQL
Existe un comando o sentencia SQL que permite la modificación del nombre de una tabla,
vista o sinónimo. Este comando es específico del SQL de ORACLE. La sentencia a la que
nos referimos es RENAME.
donde:
nombre_antiguo Es el nombre que poseía la tabla, sinónimo o vista.
nuevo_nombre Es el nombre que desearnos asignar.
INDICE:es una estructura que proporciona un acceso rápido a las filas de una tabla en base a
los valores de una o más columnas. Almacena valores y punteros a las filas en donde se
producen los valores. En el índice los valores dados están dispuestos en orden creciente o
decreciente de modo que el RDBMS puede buscar rápidamente el índice para encontrar un
valor particular. A continuación puede seguir el puntero para localizar la fila que contiene al
valor. El índice informa al RDBMS en que lugar del disco esta localizada la fila. Todo esto
acelera enormemente la ejecución de las sentencias SQL con condiciones de búsqueda.
Desventajas de !os índices:
• el índice consume espacio en el disco.
• debe actualizarse cada vez que se añade una fila a la tabla y cada vez que la columna
indexada se actualiza en una fila existente.
Utilidad:
• para condiciones de búsqueda.
• para consultas a tabla más frecuentes que inserciones y actualizaciones.
El RDBMS siempre establece un índice para la clave primaria, ya que presupone que el
acceso a la tabla se efectuará más frecuentemente a través de la clave primaria.
UNIQUE es opcional. Indica que los valores de las columnas deben ser únicos.
VERSIÓN 1 JPV- 99 41 / 49
ANEXOS A CURSO PL/SQL
ORACLE: Soporta la misma sintaxis para crear y borrar índices. Entre otras cosas se puede
especificar en qué TABLESPACE se quiere almacenar el índice:
VERSIÓN 1 JPV- 99 42 / 49
ANEXOS A CURSO PL/SQL
Solamente los usuarios autorizados pueden acceder a la BD. Cuando un usuario se conecta
emplea un nombre de usuario y una clave. En ese momento se verifica si se trata de un
usuario autorizado y en caso afirmativo cuales son sus privilegios de acceso.
Los privilegios de un usuario se agrupan en dos familias:
• Privilegios de sistema: aquellos que indican si el usuario tiene permiso para realizar
ciertas acciones sobre un conjunto de objetos (p.e. el derecho a crear tablespaces o a
borrar filas de cualquier tabla).
• Privilegios de objetos: aquellos que indican si el usuario tiene permiso para realizar ciertas
acciones sobre un objeto concreto (p.e. borrar filas de la tabla EMP).
La cantidad de distintos privilegios que se pueden dar a un usuario es muy grande, por ello,
para evitar tener que dar los privilegios de uno en uno a los usuarios se usan los roles. Un
role es un conjunto de privilegios.
Los roles predefinidos por ORACLE son:
1. CONNECT: permite conectase y acceder a las tablas públicas y a aquellas para las que
se le hayan otorgado permisos. Contiene entre otros los privilegios “ alter session” , “ create
database link” , “ create sequence” , “ create session” , “ create synonym” , “ create table” ,
“create view” .
2. RESOURCE: permite al usuario crear sus propios objetos. Los privilegios son “ create
procedure” , “ create sequence” , “ create table” , “ create trigger” .
3. DBA: el administrador de sistema. Tiene todos los privilegios de sistema.
Los objetos de una base de datos son propiedad del usuario que los creo y sólo son visibles
por su dueño inicialmente. Para que otros usuarios puedan acceder a ellos, el propietario
debe conceder a estos usuarios unos privilegios.
CONCESIÓN DE PRIVILEGIOS.
VERSIÓN 1 JPV- 99 43 / 49
ANEXOS A CURSO PL/SQL
Donde privilegio es el comando que se autoriza que el usuario ejecute sobre el objeto. Estos
pueden ser: ALTER, DELETE, INDEX, SELECT, UPDATE, DROP,...
La opción ALL otorga todos los privilegios y PUBLIC hace referencia al conjunto de todos los
usuarios. Finalmente, WITH GRANT OPTION permite al usuario que recibe estos privilegios
transmitirlos a otros usuarios.
RETIRADA DE PRIVILEGIOS.
El propietario de los objetos pueda retirar los privilegios concedidos sobre sus objetos a otros
usuarios empleando la sentencia REVOKE:
Quitar el privilegio a un usuario también significa quitárselo a los usuarios a los que este
hubiera transmitido dichos privilegios.
Nota: la concesión y retirada de roles a un usuario o de privilegios a un role sigue las mismas
reglas sintácticas que acabamos de indicar.
VERSIÓN 1 JPV- 99 44 / 49
ANEXOS A CURSO PL/SQL
Toda la información de las tablas está registrada en el diccionario del sistema (Data
Dictionary), que son tablas especiales que se crean en la instalación de ORACLE (que son
administradas por el sistema).
Conjunto de tablas y vistas que contienen información sobre la base de datos (se crean
automáticamente cuando se crea esa base). Se pueden consultar las tablas y vistas del
diccionario con la sentencia SELECT.
Tablas:
• DICTIONARY
Contiene una descripción de las tablas que constituyen el diccionario.
• ALL_CATALOG
Contiene todas las tablas, vistas y sinónimos accesibles por el usuario.
• ALL_OBJECTS
Contiene todos los objetos (tablas, vistas, índices, …) propiedad del usuario o a
los que puede acceder.
• USER_CATALOG
Contiene todas las tablas, vistas, sinónimos y secuencias propiedad del usuario.
• USER_OBJECTS
Contiene todos los objetos propiedad del usuario.
• USER_SOURCE
Contiene toda la información sobre paquetes, cuerpos de paquetes,
procedimientos y funciones.
• ALL_TAB_COLUMNS
Muestra nombres y definiciones de las columnas a las que el usuario puede
acceder.
• USER_TAB_COLUMNS
Muestra nombres y definiciones de las columnas propiedad del usuario.
• USER_INDEXES
Contiene información sobre los índices creados por el usuario.
• ALL_SYNONYMS
VERSIÓN 1 JPV- 99 45 / 49
ANEXOS A CURSO PL/SQL
VERSIÓN 1 JPV- 99 46 / 49
ANEXOS A CURSO PL/SQL
ANEXO 4: OPERADORES
OPERADORES
Se utilizan para manipular datos de forma individual y devolver un valor. Suelen estar
representados por caracteres especiales o palabras claves.
OPERADOR DESCRIPCIÓN
() Modificar prioridad de operadores.
+, - Sumar y restar.
*, / Multiplicar y dividir.
|| Concatenar cadenas de caracteres.
= Igual.
<>,!=, ¬= Distinto.
>, < Mayor y menor.
>=, <= Mayor o igual y menor o igual.
[NOT] IN Pertenencia a un conjunto.
ANY, ALL Permiten realizar comparaciones con subconsultas.
[NOT] BETWEEN c1 AND c2 Mayor o igual que c1 y menor igual que c2.
[NOT] EXISTS Verdadero si la subconsulta devuelve filas.
[NOT] LIKE Verdadero si es similar al patrón de referencia.
IS [NOT] NULL Comprueba si el valor es nulo.
NOT Negación lógica.
AND Y lógica.
OR O lógica.
UNION Une los resultados de varias consultas.
INTERSECT Filtra el resultado de dos consultas a aquellas filas que se
encuentran en ambas.
MINUS Filtra el resultado de dos consultas a aquellas filas que se
encuentran en la primera pero no en la segunda.
VERSIÓN 1 JPV- 99 47 / 49
ANEXOS A CURSO PL/SQL
OPERADORES LÓGICOS
VALOR ÚNICO
LISTA DE VALORES
VERSIÓN 1 JPV- 99 48 / 49
ANEXOS A CURSO PL/SQL
NEGACIÓN
NOT
Invierte el resultado de una expresión lógica, por ejemplo.
IS NOT NULL
NOT BETWEEN valor AND valor
NOT IN (valor,...,valor)
NOT LIKE
PATRÓN DE CONSULTA
SELECT nombre,direccion,telefono
FROM clientes
WHERE nombre LIKE '____LIBRO%';
VERSIÓN 1 JPV- 99 49 / 49