PL/SQL

PL/SQL (Procedural Language/Structured Query Language) es un lenguaje de programación incrustado en Oracle.
PL/SQL soportara todas las consultas, ya que la manipulación de datos que se usa es la misma que en SQL, incluyendo nuevas características:

• El manejo de variables.
• Estructuras modulares.
• Estructuras de control de flujo y toma de decisiones.
• Control de excepciones.

El lenguaje PL/SQL está incorporado en:

• Servidor de la base de datos.
• Herramientas de Oracle (Forms, Reports, ...).

En un entorno de base de datos los programadores pueden construir bloques PL/SQL para utilizarlos como procedimientos o funciones, o bien pueden escribir estos bloques como parte de scripts SQL*Plus.
Los programas o paquetes de PL/SQL se pueden almacenar en la base de datos como otro objeto, y todos los usuarios que estén autorizados tienen acceso a estos paquetes. Los programas se ejecutan en el servidor para ahorrar recursos a los clientes.

LDD y LMD

Lenguaje de definición de datos  (LDD)

Una vez finalizado el diseño de una base de datos y escogido un SGBD para su implementación, el primer paso consiste en especificar el esquema conceptual y el esquema interno de la base de datos, y la correspondencia entre ambos. En muchos SGBD no se mantiene una separación estricta de niveles, por lo que el administrador de la base de datos y los diseñadores utilizan el mismo lenguaje para definir ambos esquemas, es el lenguaje de definición de datos (LDD). El SGBD posee un compilador de LDD cuya función consiste en procesar las sentencias del lenguaje para identificar las descripciones de los distintos elementos de los esquemas y almacenar la descripción del esquema en el catálogo o diccionario de datos. Se dice que el diccionario contiene metadatos: describe los objetos de la base de datos.
Cuando en un SGBD hay una clara separación entre los niveles conceptual e interno, el LDD sólo sirve para especificar el esquema conceptual. Para especificar el esquema interno se utiliza un lenguaje de definición de almacenamiento (LDA). Las correspondencias entre ambos esquemas se pueden especificar en cualquiera de los dos lenguajes. Para tener una verdadera arquitectura de tres niveles sería necesario disponer de un tercer lenguaje, el lenguaje de definición de vistas (LDV), que se utilizaría para especificar las vistas de los usuarios y su correspondencia con el esquema conceptual.

Lenguaje de manejo de datos (LMD)

Una vez creados los esquemas de la base de datos, los usuarios necesitan un lenguaje que les permita manipular los datos de la base de datos: realizar consultas, inserciones, eliminaciones y modificaciones. Este lenguaje es el que se denomina lenguaje de manejo de datos (LMD).

Hay dos tipos de LMD: los procedurales y los no procedurales. Con un LMD procedural el usuario (normalmente será un programador) especifica qué datos se necesitan y cómo hay que obtenerlos. Esto quiere decir que el usuario debe especificar todas las operaciones de acceso a datos llamando a los procedimientos necesarios para obtener la información requerida. Estos lenguajes acceden a un registro, lo procesan y basándose en los resultados obtenidos, acceden a otro registro, que también deben procesar. Así se va accediendo a registros y se van procesando hasta que se obtienen los datos deseados. Las sentencias de un LMD procedural deben estar embebidas en un lenguaje de alto nivel, ya que se necesitan sus estructuras (bucles, condicionales, etc.) para obtener y procesar cada registro individual. A este lenguaje se le denomina lenguaje anfitrión. Las bases de datos jerárquicas y de red utilizan LMD procedurales.

Un LMD no procedural se puede utilizar de manera independiente para especificar operaciones complejas sobre la base de datos de forma concisa. En muchos SGBD se pueden introducir interactivamente instrucciones del LMD desde un terminal o bien embeberlas en un lenguaje de programación de alto nivel.

Los LMD no procedurales permiten especificar los datos a obtener en una consulta o los datos que se deben actualizar, mediante una sola y sencilla sentencia. El usuario o programador especifica qué datos quiere obtener sin decir cómo se debe acceder a ellos. El SGBD traduce las sentencias del LMD en uno o varios procedimientos que manipulan los conjuntos de registros necesarios. Esto libera al usuario de tener que conocer cuál es la estructura física de los datos y qué algoritmos se deben utilizar para acceder a ellos. A los LMD no procedurales también se les denomina declarativos. Las bases de datos relacionales utilizan LMD no procedurales, como SQL (Structured Query Language) o QBE (Query-By-Example). Los lenguajes no procedurales son más fáciles de aprender y de usar que los procedurales, y el usuario debe realizar menos trabajo, siendo el SGBD quien hace la mayor parte.

La parte de los LMD no procedurales que realiza la obtención de datos es lo que se denomina un lenguaje de consultas. En general, las órdenes tanto de obtención como de actualización de datos de un LMD no procedural se pueden utilizar interactivamente, por lo que al conjunto completo de sentencias del LMD se le denomina lenguaje de consultas, aunque es técnicamente incorrecto.

procedimientos

Un procedimiento es un subprograma que ejecuta una acción especifica y que no devuelve ningún valor. Un procedimiento tiene un nombre, un conjunto de parámetros (opcional) y un bloque de código.
    La sintaxis de un procedimiento almacenado es la siguiente:

CREATE [OR REPLACE] 
PROCEDURE <procedure_name> [(<param1> [IN|OUT|IN OUT] <type>, 
                             <param2> [IN|OUT|IN OUT] <type>, ...)] 
IS  -- Declaracion de variables locales
BEGIN
  -- Sentencias[EXCEPTION]  -- Sentencias control de excepcionEND [<procedure_name>];

El uso de OR REPLACE permite sobreescribir un procedimiento existente. Si se omite, y el procedimiento existe, se producirá, un error.
    La sintaxis es muy parecida a la de un bloque anónimo, salvo porque se reemplaza la seccion DECLARE por la secuencia PROCEDURE ... IS en la especificación del procedimiento.
    Debemos especificar el tipo de datos de cada parámetro. Al especificar el tipo de dato del parámetro no debemos especificar la longitud del tipo.
    Los parámetros pueden ser de entrada (IN), de salida (OUT) o de entrada salida (IN OUT). El valor por defecto es IN, y se toma ese valor en caso de que no especifiquemos nada.

CREATE OR REPLACE 
PROCEDURE Actualiza_Saldo(cuenta NUMBER, 
                          new_saldo NUMBER)
IS  -- Declaracion de variables locales
BEGIN
  -- Sentencias
  UPDATE SALDOS_CUENTAS 
	SET SALDO = new_saldo, 
            FX_ACTUALIZACION = SYSDATE
  WHERE CO_CUENTA = cuenta;
END Actualiza_Saldo;  

También podemos asignar un valor por defecto a los parámetros, 

utilizando la clausula DEFAULT  o el operador de asiganción (:=) . 

CREATE OR REPLACE 
PROCEDURE Actualiza_Saldo(cuenta NUMBER, 
                          new_saldo NUMBER DEFAULT 10 )
IS  -- Declaracion de variables locales
BEGIN
  -- Sentencias
  UPDATE SALDOS_CUENTAS 
	SET SALDO = new_saldo, 
            FX_ACTUALIZACION = SYSDATE
  WHERE CO_CUENTA = cuenta;
END Actualiza_Saldo; 
 
 Una vez creado y compilado el procedimiento almacenado podemos 
ejecutarlo. Si el sistema nos indica que el procedimiento se ha creado 
con errores de compilación podemos ver estos errores de compilacion con 
la orden SHOW ERRORS en SQL *Plus.
    Existen dos formas de pasar argumentos a un procedimiento 
almacenado a la hora de ejecutarlo (en realidad es válido para cualquier
 subprograma). Estas son:
Notación posicional: Se pasan los valores de los parámetros en el 
mismo orden en que el procedure los define.
 
 
BEGIN	Actualiza_Saldo(200501,2500);
        COMMIT;
END;  

Estructuras de control en Transact SQL

Estructura condicional IF

    La estuctura condicional IF permite evaluar una expresion booleana (resultado SI - NO), y ejecutar las operaciones contenidas en el bloque formado por BEGIN END.

DECLARE @coPais int,
 @descripcion varchar(255)
set @coPais = 5
set @descripcion = 'España'

IF EXISTS(SELECT * FROM PAISES 
          WHERE CO_PAIS = @coPais) 
  BEGIN
 UPDATE PAISES
 SET DESCRIPCION = @descripcion
 WHERE CO_PAIS = @coPais
  END

ELSE
  BEGIN
 INSERT INTO PAISES
 (CO_PAIS, DESCRIPCION) VALUES (@coPais, @descripcion)
  END

Estructura condicional CASE

    La estructura condicional CASE permite evaluar una expresion y devolver un valor u otro.

    La sintaxis general de case es:

    CASE <expresion>
        WHEN <valor_expresion> THEN <valor_devuelto>
        WHEN <valor_expresion> THEN <valor_devuelto>
        ELSE <valor_devuelto>  -- Valor por defecto
    END

Ejemplo de CASE.

DECLARE @Web varchar(100),
            @diminutivo varchar(3)    SET @diminutivo = 'DJK'   

SET @Web = (CASE @diminutivo
                    WHEN 'DJK' THEN 'www.devjoker.com'
                    WHEN 'ALM' THEN 'www.aleamedia.com'
                    ELSE 'www.devjoker.com'
                END)    PRINT @Web 

Bucle WHILE

     El bucle WHILE se repite mientras expresion se evalue como verdadero.

    Es el único tipo de bucle del que dispone Transact SQL.

WHILE <expresion>  
    BEGIN
       ...
    END

Un ejemplo del bucle WHILE.

    DECLARE @contador int
    SET @contador = 0
    WHILE (@contador < 100)
    BEGIN
      SET @contador = @contador + 1

     PRINT 'Iteracion del bucle ' + cast(@contador AS varchar)
    END 

Cursores en SQL

Un cursor es una variable que nos permite recorrer con un conjunto de resultados obtenido a través de una sentencia SELECT fila a fila.

    Cuando trabajemos con cursores debemos seguir los siguientes pasos.

• Declarar el cursor, utilizando DECLARE
• Abrir el cursor, utilizando OPEN
• Leer los datos del cursor, utilizando FETCH ... INTO
• Cerrar el cursor, utilizando CLOSE
• Liberar el cursor, utilizando DEALLOCATE

    La sintaxis general para trabajar con un cursor es la siguiente.

-- Declaración del cursorDECLARE <nombre_cursor> CURSOR 
FOR<sentencia_sql>

-- apertura del cursorOPEN <nombre_cursor> 

-- Lectura de la primera fila del cursor
FETCH <nombre_cursor> INTO <lista_variables>

WHILE (@@FETCH_STATUS = 0)
BEGIN 
-- Lectura de la siguiente fila de un cursor
FETCH <nombre_cursor> INTO <lista_variables>
... 
END -- Fin del bucle WHILE

-- Cierra el cursor
CLOSE <nombre_cursor>
-- Libera los recursos del cursorDEALLOCATE <nombre_cursor> 

El siguente ejemplo muestra el uso de un cursor.
 

 Declaracion de variables para el cursorDECLARE @Id int,
 @Nombre varchar(255),
 @Apellido1 varchar(255),
 @Apellido2 varchar(255),
 @NifCif varchar(20),
 @FxNacimiento datetime

-- Declaración del cursorDECLARE cClientes CURSOR FOR
SELECT  Id, Nombre, Apellido1, 
 Apellido2, NifCif, FxNacimiento
FROM CLIENTES
-- Apertura del cursorOPEN cClientes
-- Lectura de la primera fila del cursorFETCH cClientes INTO    @id, @Nombre, @Apellido1, 
   @Apellido2, @NifCif, @FxNacimiento

WHILE (@@FETCH_STATUS = 0 )
BEGIN
PRINT @Nombre + ' ' + @Apellido1 + ' ' + @Apellido2
-- Lectura de la siguiente fila del cursor
FETCH cClientes INTO    @id, @Nombre, @Apellido1, 
   @Apellido2, @NifCif, @FxNacimiento
END
-- Cierre del cursorCLOSE cClientes
-- Liberar los recursosDEALLOCATE cClientes
 

Funciones en PL/SQL

Una función es un subprograma que devuelve un valor.
    La sintaxis para construir funciones es la siguiente:

CREATE [OR REPLACE]
FUNCTION <fn_name>[(<param1> IN <type>, <param2> IN <type>, ...)] 
RETURN <return_type> 
IS
  result <return_type>;
BEGIN
 
  return(result);
[EXCEPTION]  -- Sentencias control de excepcion
END [<fn_name>];

 El uso de OR REPLACE permite

 sobreescribir una función existente. Si se 

omite, y la función existe, se producirá, un error. 
    La sintaxis de los parámetros es la misma

 que en los procedimientos almacenado,

 exceptuando que solo pueden ser de entrada. 
    Ejemplo:


CREATE OR REPLACE
FUNCTION fn_Obtener_Precio(p_producto VARCHAR2) 
RETURN NUMBER
IS
  result NUMBER;
BEGIN
  SELECT PRECIO INTO result
  FROM PRECIOS_PRODUCTOS
  WHERE CO_PRODUCTO = p_producto;
  return(result);
EXCEPTION 
WHEN NO_DATA_FOUND THEN
  return 0;
END ;
 

 Si el sistema nos indica que el la función se ha creado con errores de 
compilación podemos ver estos errores de
 compilacion con la orden SHOW ERRORS en
 SQL *Plus.

    Una vez creada y compilada la función podemos ejecutarla de la siguiente forma:

DECLARE  Valor NUMBER;BEGIN Valor := fn_Obtener_Precio('000100');

END;  

 Las funciones pueden utilizarse en sentencias SQL de 

manipulación de datos (SELECT, UPDATE, INSERT y DELETE): 

SELECT CO_PRODUCTO, 
       DESCRIPCION,
       fn_Obtener_Precio(CO_PRODUCTO)
FROM PRODUCTOS; 

modelo relacional

INTRODUCCIÓN

La introducción por Codd, muy a finales de los sesenta, de la teoría de las relaciones en el campo de las bases de datos supuso un importante paso en la investigación de los SGBD, suministrando un sólido fundamento teórico para el desarrollo, dentro de este enfoque relacional, de nuevos productos. El documento de Codd propone un modelo de datos basado en la teoría de las relaciones, en donde los datos se estructuran lógicamente en forma de relaciones ‑tablas‑, siendo un objetivo fundamental del modelo mantener la independencia de esta estructura lógica respecto al modo de almacenamiento y a otras características de tipo físico.

El trabajo publicado por Codd (1970), presentaba un nuevo modelo de datos que perseguía una serie de objetivos, que se pueden resumir en los siguientes.

q       Independencia física: es decir, el modo en el que se almacenan los datos no influya en su manipulación lógica y, por tanto, los usuarios que acceden a esos datos no tienen que modificar sus programas por cambios en el almacenamiento físico.

q       Independencia lógica: esto es, que el añadir, eliminar o modificar objetos de la base de datos no repercuta en los programas y/o usuarios que están accediendo a subconjuntos parciales de los mismos (vistas).

q       Flexibilidad: en el sentido de poder presentar a cada usuario los datos de la forma en que éste prefiera.

q       Uniformidad: las estructuras lógicas de los datos presentan un aspecto uniforme, lo que facilita la concepción y manipulación de la base de datos por parte de los usuarios.

q       Sencillez: las características anteriores, así como unos lenguajes de usuario muy sencillos, producen como resultado que el modelo de datos relacional sea fácil de comprender y de utilizar por parte del usuario final.

Para conseguir los objetivos citados, Codd introduce el concepto de "relación" (tabla) como una estructura básica del modelo. Todos los datos de la BD se representan en forma de relaciones cuyo contenido varía en el tiempo.

Con respecto a la parte dinámica del modelo, se proponen un conjunto de operadores que se aplican a las relaciones. Todos ellos conforman el Álgebra Relacional.

ESTRUCTURA DEL MODELO RELACIONAL

La relación es el elemento básico en el modelo relacional y se puede representar como una tabla:

Nombre

Atributo 1	Atributo 2	.....................	Atributo n
XXXXXXXX	XXXXXXXX	XXXXXXXX	XXXXXXXX	Tupla 1
XXXXXXXX	XXXXXXXX	XXXXXXXX	XXXXXXXX	Tupla 2
XXXXXXXX	XXXXXXXX	XXXXXXXX	XXXXXXXX	.
XXXXXXXX	XXXXXXXX	XXXXXXXX	XXXXXXXX	.
XXXXXXXX	XXXXXXXX	XXXXXXXX	XXXXXXXX	Tupla n

En ella podemos distinguir un conjunto de columnas, denominadas atributos, que representan propiedades de la misma y que están caracterizadas por un nombre; y un conjunto de filas llamadas tuplas que son las ocurrencias de la relación. Existen también unos dominios donde los atributos toman sus valores.

El número de filas de una relación se denomina cardinalidad de la relación y el número de columnas es elgrado de la relación.

Ejemplo:  AUTOR

Nombre	Nacionalidad	Institucion
	España	O.N.U.
John	EE.UU.	O.M.S.
Pierre	Francia	N.A.S.A.

Una relación se puede representar en forma de tabla, pero va a tener una serie de elementos característicos:

·        No puede haber filas duplicadas, es decir, todas las tuplas tienen que ser distintas.

·        El orden de las filas es irrelevante.

·        La tabla es plana, es decir, en el cruce de una fila y una columna sólo puede haber un valor (no se admiten atributos multivaluados).

vi                                                                V   I  D  E O 

   

                                                                                        


h