Bases de Datos B.

Módulo 2
Bases de datos
Módulo 2: Bases de Datos
Contenido
8. TUTORIAL DE INSTALACIÓN SGBD ORACLE .................................................................5
8.1. Instalación software JDK ........................................................................................................ 5
8.2. Instalación del servidor Oracle Database Express .................................................................. 10
8.3. Instalación del cliente Oracle: SQL Developer........................................................................ 16
9. CREACIÓN DE BASES DE DATOS .............................................................................. 21
9.1. Creación de bases de datos en Oracle ................................................................................... 21
9.2. Creación de BBDD en MySQL ................................................................................................ 26
10. GESTIÓN DE USUARIOS .............................................................................................. 33
10.1. Administración de usuarios ................................................................................................. 33
10.2. Administración de privilegios .............................................................................................. 48
10.3. Administración de roles ...................................................................................................... 58
10.4. Administración de perfiles .................................................................................................. 59
10.5. Normativa legal vigente sobre la protección de datos ......................................................... 61
11. PROGRAMACIÓN EN BASES DE DATOS (BBDD) ..................................................... 62
11.1. Entornos de desarrollo al entorno de las BBDD ................................................................... 62
11.2. Sintaxis del lenguaje de programación ................................................................................ 64
11.3. Procedimientos y funciones ................................................................................................ 77
11.4. Control de errores .............................................................................................................. 86
11.5. Cursores y transacciones ..................................................................................................... 91
11.6. Disparadores o triggers..................................................................................................... 105
12. USO DE LAS BBDD OBJETO-RELACIONALES ......................................................... 111
12.1. Características .................................................................................................................. 112
12.2. Tipos de datos objeto ....................................................................................................... 115
12.3. Definición de tipos de objeto ............................................................................................ 116
12.4. Herencia ........................................................................................................................... 123
Página 2 de 135
12.5. Identificadores, referencias............................................................................................... 125
12.6. Tipos de datos colección ................................................................................................... 126
12.7. Declaración e inicialización de objetos .............................................................................. 129
12.8. Sentencia SELECT. Inserción, modificación y borrado de objetos........................................ 131
BIBLIOGRAFÍA .................................................................................................................. 134
Página 3 de 135
En el libro anterior de bases de datos A ya estuvimos analizando los primeros pasos

a dar para la creación y uso de una base de datos (BD): recoger las necesidades del
cliente, crear el modelo entidad-relación, pasar del modelo entidad-relacional
modelo relacional, instalar el sistema gestor de base de datos (SGBD), crear la BD en
el SGBD y realizar consultas básicas.
El SGBD que habíamos utilizado como referencia fue MYSQL, un software más
orientado al tratamiento de bases de datos (BBDD) en sitios web y, por otro lado,
introdujimos otro SGBD: Oracle.
En este libro nos centraremos en aprender los conceptos con Oracle, pero sin dejar
totalmente de lado MySQL, de modo que ilustraremos todos los ejemplos en Oracle
y algunos también en MySQL.
De este modo, tendremos un conocimiento variado de los SGBD más utilizados en el
ámbito laboral. Además, utilizaremos un lenguaje de programación creado y
utilizado expresamente por y para Oracle.
Para que podamos trabajar con este SGBD, en primer lugar vamos a ver paso a paso
el proceso de instalación de su software y su posterior utilización. Para ello,
crearemos tablas mediante diferentes comandos SQL.
Página 4 de 135
8. Tutorial de instalación SGBD Oracle
Para la instalación del SGBD de Oracle necesitamos instalar primero el software de

Java correspondiente. Por tanto, en este tema analizaremos primero la instalación
de la herramienta JDK, y después del cliente y el servidor Oracle.
8.1. Instalación software JDK
El SGBD de Oracle está desarrollado en Java y se ejecuta sobre la plataforma de

Java, por tanto, para usar la BD de Oracle debemos tener instalada en nuestra
computadora una serie de requisitos Java.
Oracle nos suministra vía web la herramienta JDK (Java Development Kit), que es
una herramienta que todo programa implementado en Java necesita tener.
Para instalar JDK en nuestra computadora debemos seguir estos pasos:

1. Accedemos a la página web oficial de Oracle.
https://www.oracle.com/es/index.html
Página 5 de 135
2. Navegamos por la web hasta acceder a la sección de descargas JDK.
https://www.oracle.com/technetwork/es/java/javase/downloads/index.html
3. Seleccionamos la descarga para el sistema operativo y arquitectura que nos

corresponda en nuestra computadora (Windows, Linux, MacOS…).
Página 6 de 135
4. Aceptamos las condiciones de uso antes de la descarga.
5. Oracle nos solicitará una cuenta. En caso de no tenerla, podemos crear una fácil y
gratis.
Página 7 de 135
6. Una vez realizado el paso anterior, descargaremos en nuestra computadora el

software JDK de Oracle.
7. Una vez descargado, comenzaremos con el proceso de instalación.
Página 8 de 135
8. La instalación nos pregunta por la ruta de la carpeta de instalación. Tiene una

asignada por defecto, pero podemos cambiarla haciendo clic en Change.
9. La instalación avanzará de manera automática.
Página 9 de 135
10. Hasta que el programa de instalación nos avise de que ya está instalado.
Adicionalmente, nos ofrece la opción de acceder a tutoriales, guías y otros
contenidos. Esto no es estrictamente necesario, pero podríamos optar por ello
haciendo clic en Next Steps:
8.2. Instalación del servidor Oracle Database Express
Una vez ya tenemos instalado el JDK, pasaremos a descargar e instalar el servidor

de la BD. Oracle posee diversos SGBD, pero en nuestro caso usaremos Oracle
Database Express que, hasta la fecha, es el único servidor de BBDD que Oracle
suministra de manera gratuita.
Página 10 de 135
1. Accedemos a la sección de descarga de Oracle Database Express dentro de la web

de Oracle y seleccionamos la opción Descargar.
https://www.oracle.com/es/database/technologies/appdev/xe.html
2. Elegimos la descarga correspondiente según el sistema operativo de nuestra

computadora. Para ello, la web nos solicitará aceptar las condiciones de uso y tener
una cuenta de Oracle, al igual que en el proceso de descarga e instalación del JDK.
Página 11 de 135
3. Tras el paso anterior, un archivo con el software deseado se descargará en modo

comprimido en nuestra computadora.
4. Una vez descargado el archivo, lo descomprimimos
5. Una vez descomprimido, pasamos a la configuración e instalación del servidor.

Para ello, ejecutamos el archivo de configuración llamado Setup
Página 12 de 135
6. Nos aparecerá un asistente de instalación que nos guiará durante dicho proceso,
en el que nos pedirá la confirmación de acuerdo de licencia y la carpeta a usar para
la instalación.
Página 13 de 135
7. Llegado el momento, el sistema nos pedirá una contraseña para el servidor. Es

muy importante recordar esta contraseña, porque en caso de olvidarla,
probablemente tendríamos que volver a instalar el servidor. Una vez suministrada
la contraseña, seleccionamos la opción Siguiente y confirmamos la instalación.
Página 14 de 135
8. A continuación, la instalación se efectuará. Puede tardar unos minutos.
Página 15 de 135
9.Cuando el asistente finalice la instalación, solo quedará seleccionar la opción

Terminar.
Tras este proceso, ya tenemos instalado el servidor de la BD. Ya solo nos falta
instalar la parte del cliente.
8.3. Instalación del cliente Oracle: SQL Developer
Una vez realizada la instalación de la parte del servidor, procederemos a instalar la

parte del cliente. Para ello usaremos el software Oracle SQL Developer. El software
cliente se conectará al software servidor y le lanzará las consultas SQL. Por tanto,
debe existir una conexión entre Database Express y SQL Developer.
Los pasos que debemos seguir para la instalación del SQL Developer de Oracle son:
descargar el software, desempaquetar y descomprimir el software y ejecutarlo. Los
detallamos a continuación.
Página 16 de 135
Descargar SQL Developer

1. Accedemos a la página web de Oracle y accedemos a la sección del SQL
Developer.
https://www.oracle.com/es/tools/downloads/sqldev-v192-downloads.html
Página 17 de 135
2. Seleccionamos la descarga adecuada en función de nuestro sistema operativo.

Aceptamos los términos y condiciones para la descarga del software.
3. Al igual que con otras instalaciones de Oracle, la web nos pedirá estar registrados
en una cuenta de Oracle. Podemos usar la misma cuenta que utilizamos
anteriormente.
4. Una vez validada nuestra cuenta, se descargará automáticamente el archivo de

SQL Developer.
Página 18 de 135
Desempaquetar y descomprimir el software

El archivo se descargará en un formato comprimido. Debemos extraerlo para su
utilización normal.
Ejecutar el software
Una vez lo hayamos extraído, haremos doble clic sobre el ejecutable. El sistema
probablemente nos pedirá la ruta donde está ubicado el JDK que hemos instalado
anteriormente. Entonces, se abrirá el software SQL Developer.
Página 19 de 135
Una vez comprobado que el cliente SQL Developer funciona

correctamente, es recomendable crear un acceso directo de esta
aplicación en el escritorio.
Página 20 de 135
9. Creación de bases de datos
En este tema vamos a aprender a crear una BD, tanto en el SGBD de Oracle como en
el SGBD de MySQL. Emplearemos el mismo ejemplo para ambos sistemas.
En el caso del SGBD de Oracle, primero deberemos enlazar manualmente la parte
del cliente con la del servidor. En el caso de MySQL y Workbench, por defecto
deberían estar conectados.
9.1. Creación de bases de datos en Oracle
Antes de empezar con la creación de la BD vamos a conectar el software cliente con

el servidor. Lo primero que haremos es comprobar que el servidor se está
ejecutando.
De no ser así, basta con hacer doble clic sobre su icono en el escritorio.
A continuación, ejecutaremos el cliente y, accediendo a Conexiones, crearemos
una nueva conexión (+).
Nota: En el caso de no tener un icono en el escritorio, podemos abrir tanto el

software cliente como el servidor a través de la consola del sistema operativo. Para
ello, se debe conocer la ruta donde está instalado.
Para comprobar en el sistema operativo si el software servidor se está ejecutando,

podemos listar todos los servicios que están en ejecución. En el caso de Windows,
podemos consultarlo en la opción Servicios, tal como se muestra en la imagen 2.1.a,
en la cual podemos observar cómo los procesos ServiceXE y el TNSListener están en
ejecución, por lo que nos aseguramos de que el servidor está activo.
Página 21 de 135
Imagen 2.1.a
Para simplificar la prueba, vamos a nombrar la conexión exactamente igual que al

usuario que la va a utilizar. Por tanto, el nombre de la conexión va a ser SYSTEM.
• Usuario: SYSTEM
• Contraseña: root
Si quisiéramos un usuario diferente, tendríamos que crearlo primero en el servidor

para que, después, pudiéramos utilizarlo en una conexión.
Podemos seleccionar la opción Guardar contraseña para que quede memorizada y
no nos la vuelva a pedir. Seguidamente, probaremos la conexión comprobando que
el estado es correcto. Una vez hecha esta comprobación, podremos guardar y
conectar.
Imagen 2.1.b: En la imagen observamos numerados el orden de los pasos que se deben seguir para la
nueva conexión.
Página 22 de 135
Si hemos seguido los pasos correctamente, tendremos una conexión a la BD

perfectamente funcional y con todos los privilegios.
Imagen 2.1.c
Página 23 de 135
A continuación, veremos los diferentes pasos para crear las tablas dentro de una
conexión que actuará como BD.
1. Creamos las tablas mediante comandos SQL.
Imagen 2.1.d
2. A continuación, seleccionamos los comandos y pulsamos sobre el acceso directo

Sentencia de ejecución.
Imagen 2.1.e
Página 24 de 135
Imagen 2.1.f
3. Para comprobar que las órdenes han sido efectuadas con éxito, refrescamos la
conexión y, en el apartado de Tablas deben aparecer las que hemos creado.
Imagen 2.1.g
Página 25 de 135
9.2. Creación de BBDD en MySQL
Para crear una BBDD en MySQL daremos los siguientes pasos:

1. Iniciar correctamente MySQL Workbench.
2. Conectarnos al servidor.
3. Codificar un ejemplo de una BD nueva.
4. Guardar la BD en el sistema.
5. Asegurarse de que la BD queda almacenada correctamente.
1. Lo primero que debemos hacer es abrir MySQL Workbench. Para ello, debemos
buscar la aplicación en nuestro sistema operativo y ejecutarla. Por ejemplo, en
Windows 10 podemos escribir directamente workbench en la barra de tareas y
hacer clic en el icono de MySQL Workbench.
Página 26 de 135
De tal modo que se debería abrir MySQL Workbench en nuestro sistema.
2. Como podemos observar en la imagen anterior, Workbench nos ofrece la opción

de conectarnos al servidor MySQL.
Página 27 de 135
Al hacer doble clic en la referencia al servidor, el sistema nos pedirá la contraseña

para conectarnos al mismo.
El Workbench nos abrirá una nueva pestaña. Si deseamos conocer más detalles
sobre la conexión al servidor, podemos hacer clic en la opción Server Status, tal
como se señala en la imagen.
Página 28 de 135
Al hacer clic en Server Status podremos conocer los detalles de la conexión al

servidor.
3. Para crear código MySQL en Workbench utilizaremos el editor de textos que nos
ofrece Workbench.
Página 29 de 135
En el editor codificaremos la BD deseada. En este caso, usaremos el mismo ejemplo

de una BD nueva que hicimos con Oracle:
4. Cuando el código de la nueva BD ya esté creado, debemos ejecutarlo para que se

almacene en el SGBD. Al ejecutarlo, Workbench nos informará del éxito de la
operación o de los posibles errores, en caso de que los hubiese. Para ello debemos
presionar el símbolo del rayo.
Página 30 de 135
Al ejecutarse el código, Workbench nos informará del éxito o error del código en la
sección inferior Action Output. En este caso el código se ejecutó correctamente.
5. Al ejecutarlo de manera exitosa, la nueva BD quedará registrada en el servidor.

Para verla en la sección de SCHEMAS, debemos hacer clic en el símbolo de
Actualizar.
Página 31 de 135
Independientemente de la BD ya creada y guardada en el servidor, es conveniente

guardar el código que hemos creado en Workbench. Para ello usaremos el icono
Guardar.
De este modo, habremos finalizado la tarea de Crear una BD nueva en el servidor

MySQL a través de la interfaz gráfica de MySQL Workbench.
Página 32 de 135
10. Gestión de usuarios
10.1. Administración de usuarios
Para interactuar con una BD se utilizan los usuarios. Existen usuarios de todo tipo:
desde usuarios de sistema hasta usuarios con muchas restricciones.
Las BBDD albergan una lista válida de usuarios a los que se les permite la conexión
al sistema. Por este, motivo se debe crear una cuenta de usuario para cada persona
que pretenda acceder a la BD, en la que se especifique: el nombre de usuario, el
método de autentificación, el perfil de usuario y, en el caso de Oracle, el tablespace.
10.1.1. Administración de usuarios en Oracle

En Oracle vamos a diferenciar las dos formas por las que se puede autentificar un
usuario:
• Autentificación por BD: la administración de la cuenta es de tipo
usuario/contraseña, de forma que se va a guardar encriptada y su
autentificación se realizará por Oracle.
• Autentificación externa: la cuenta la mantiene Oracle, aunque la
administración de la contraseña y la autentificación de usuario es realizada
externamente por el sistema operativo. El usuario tiene la posibilidad de
conectarse a la BD sin necesidad de indicar el nombre del usuario o la clave,
porque es el mismo nombre de usuario del sistema operativo.
• Cuentas administrativas: tal como hemos podido comprobar al instalar Oracle,
existen por defecto dos cuentas con permisos administrativos concedidos para
realizar tareas de optimización y monitorización de las BBDD.
- SYS: funciona como súper administrador de la BD (rol de DBA) y no
interesa modificar su esquema porque es donde se crea el diccionario de
datos.
- SYSTEM: contiene el mismo rol que la anterior y, por defecto, tiene una
serie de tablas y vistas administrativas ya creadas.
- SYSMAN: realiza tareas administrativas utilizando Enterprise Manager.
- DBSMNP: controla la aplicación Enterprise Manager.
• Privilegios administrativos: la seguridad en las BBDD es un factor muy
importante, ya que en caso de violaciones de seguridad los datos pueden
quedar expuestos.
Página 33 de 135
Por este motivo, hay que estar muy atentos a los privilegios y accesos que se
otorgan a los DBA (Administradores de Base de Datos). Existen ciberataques
dirigidos especialmente a los usuarios con más privilegios en una empresa,
aprovechando sus cuentas para hacer un mal uso.
Para evitar este tipo de incidentes, se recomienda realizar una separación de
responsabilidades. Esta separación consiste en dividir las tareas administrativas
entre diferentes usuarios y evitar que recaigan en un solo individuo todopoderoso.
Esto reduce la probabilidad de que un usuario abuse de los privilegios y, por otro
lado, minimiza el riesgo de recibir un ataque en este tipo de cuentas.
Existen dos grandes privilegios administrativos del sistema capacitados para realizar
operaciones de alto nivel, como crear, cerrar, iniciar, realizar copias de seguridad o
recuperar la BD:
• SYSDBA: tiene un control total sobre la BD.
• SYSOPER: permite al usuario realizar las tareas operativas básicas, pero sin
poder visualizar los datos.
Una buena práctica para realizar la separación de responsabilidades es evitar utilizar

el privilegio SYSDBA y, en su lugar, conceder privilegios más específicos como
SYSBACKUP, SYSDG, SYSRAC y SYSKM para realizar las tareas de copias de seguridad
de la BD, gestión de la protección de los datos, gestión de RAC y gestión de las
credenciales de usuarios.
La vista v$PWFILE_USERS nos permite examinar a los usuarios administrativos.
• Características de los usuarios de Oracle

Como hemos explicado anteriormente, los usuarios deben poseer un nombre.
Veamos las restricciones que existen a la hora de crearlos:
- Nombre usuario: debe ser único e irrepetible. Su longitud máxima no ha de
sobrepasar los 30 caracteres. Además, solamente puede contener caracteres
alfanuméricos y los signos $ y _como caracteres especiales.
- Configuración física: espacio que posee el usuario para almacenar su
información y límite de almacenamiento. En Oracle se denomina tablespace.
- Perfil asociado: son los diferentes recursos de los que dispone el usuario del
sistema.
- Privilegios y roles: concesión de funciones que pueden realizar los usuarios.
Página 34 de 135
• STATUS (estados) de una cuenta de usuario

- OPEN (abierta): el estado de la cuenta es accesible, por lo que el usuario
puede trabajar sin problema en las acciones habilitadas.
- EXPIRED (expirada): la cuenta de usuario ha agotado el tiempo máximo del
que disponía, por lo que su acceso queda denegado.
- EXPIRED GRACE (expirada en gracia): la cuenta ha caducado, pero sigue
siendo accesible. En este estado, se conceden X días para cambiar la
contraseña antes de denegar el acceso.
- LOCKED (bloqueada): el administrador del sistema ha bloqueado la cuenta,
por lo que el usuario no podrá realizar ninguna acción.
- LOCKED TIMED (bloqueada por tiempo): tras varios intentos fallidos de inicio
de sesión, la cuenta queda bloqueada temporalmente
(FAILED_LOGIN_ATTEMPTS).
- EXPIRED & LOCKED (expirada y bloqueada): la cuenta ha caducado y ha sido
bloqueada por el administrador del sistema.
• Creación de usuario
Antes de comenzar con la creación de usuarios, debemos asegurarnos de que nos
conectamos a un usuario que posee permisos concedidos para la creación de
usuarios.
Existen dos formas diferentes para conectarnos a un usuario:
1. Mediante la creación de una conexión, como hemos visto en el apartado
anterior con el usuario SYSTEM
2. Mediante comandos en Oracle (Run SQL Command Line)
Página 35 de 135
La sentencia para crear una cuenta de usuario que permita la autentificación de

este en el SGBD con un nivel determinado de privilegios es:
CÓDIGO
-- Sintaxis
CREATE USER nombre_usuario IDENTIFIED BY 'passwords' [opciones];
CÓDIGO
-- Ejemplo
CREATE USER ilerna IDENTIFIED BY 'root';
Para saber a qué usuario estamos conectados utilizaremos el siguiente comando:
CÓDIGO
-- Ejemplo
SHOW USER
Página 36 de 135
Si estamos trabajando con las hojas de trabajo del cliente de Oracle SQL
Developer, hay que tener en cuenta que, al crear un usuario y conectarnos a él,
una vez terminemos el script, este se desconectará automáticamente. En el caso
de estar utilizando la consola de comandos, este usuario se quedará conectado
hasta que cerremos la conexión o la consola.
Sentencia de creación y conexión:

CREATE USER ilerna IDENTIFIED BY 'root';
GRANT CREATE SESSION TO ilerna;
CONN ilerna / root
Cuando se crea un usuario, también podemos elegir las siguientes opciones:
CÓDIGO
-- Sintaxis
CREATE USER nombre {IDENTIFIED BY 'contraseña'|

EXTERNALLY|GLOBALLY AS nombreGlobal}
[DEFAULT TABLESPACE tableSpacePorDefecto]
[TEMPORARY TABLESPACE tableSpacetTemporal]
[QUOTA{cantidad[K|M]|UNLIMITED}ON tablespace
[QUOTA{cantidad[K|M]|UNLIMITED}ON tablespace[…]]]
[PASSWORD EXPIRE]
[ACCOUNT{UNLOCK|LOCK}];
[PROFILE{perfil|DEFAULT}]
Página 37 de 135
CÓDIGO
-- Ejemplo
CREATE USER ilerna IDENTIFIED BY 'root'

DEFAULT TABLESPACE 'Alumnos'
QUOTA 15M ON'Alumnos'/*Se dan 15MBytes de espacio en el tablespace*/
• Modificación de usuario
CÓDIGO
-- Sintaxis
ALTER USER nombre_usuario [opciones];

-- Ejemplo
ALTER USER ilerna ACCOUNT UNLOCK;
Para quitarle el límite de cuota:
CÓDIGO
-- Ejemplo
ALTER USER ilerna QUOTA UNLIMITED ON Alumnos;
Página 38 de 135
• Borrado de usuario
CÓDIGO
-- Sintaxis
DROP USER nombre_usuario [CASCADE];
La opción CASCADE elimina primero los objetos que están asociados al usuario y,
después, el usuario. Por tanto, emplearemos la opción de eliminar el usuario con
CASCADE si tenemos intención de borrar todos sus objetos asociados:
CÓDIGO
-- Ejemplo
DROP USER ilerna CASCADE;
Cada vez que borremos un usuario, borraremos también el esquema asociado a sus
objetos.
• Consulta de usuario
Mediante DBA_USERS se muestra la lista y configuración de los usuarios del
sistema. Para visualizar la estructura de un usuario podemos utilizar el comando
DESC DBA_USERSo DESCRIBE DBA_USERS. DESC es un diminutivo de DESCRIBE.
CÓDIGO
-- Ejemplo
DESC DBA_USERS;
Página 39 de 135
Para conocer todos los usuarios del sistema podemos usar la siguiente expresión:
CÓDIGO
-- Ejemplo
SELECT * FROM DBA_USERS;
• Espacios en tablas (tablespaces)

Los espacios de tablas son almacenes para estructuras de una BD (tablas, vistas,
procedimientos, etc.). Una BD consta de uno o más espacios de tablas.
Por defecto, Oracle crea los siguientes tablespaces:
1. SYSTEM (diccionario de datos)
2. SYSAUX (componentes opcionales de la BD)
3. TEMP
4. UNDOTBS1 (undotablespace, para rollbacks de transacciones)
5. USERS
• Operaciones con espacios de tablas
Vemos la sintaxis de creación de un tablespace que contiene todas las opciones que
le podemos indicar.
Para crear un tablespace asociado a un usuario lo primero que haremos es crear el

espacio de tablas relacionado con un fichero físico de nuestro equipo:
Página 40 de 135
CÓDIGO
-- Sintaxis
CREATE [TEMPORARY/UNDO] TABLESPACE <tablespace_nombre>
DATAFILE/TEMPFILE' <datafile01_name y el Path donde creamos el
fichero> 'SIZE <INTEGERN>[,
'<datafile02_name y el Path donde creamos el fichero>' SIZE <INTEGERN>[,
'<datafile0N_name y el Path donde creamos el fichero>' SIZE <INTEGERN>[,...]]]
BLOCKSIZE <DB_BLOCK_SIZE parameter/2k/4k/8k/16k/32k>
AUTOEXTEND {[OFF/ON(NEXT<INTEGERK/M> MAXSIZE <INTEGERK/M>)/UNLIMITED]}
LOGGING/NOLOGGING(Logging default)
ONLILE/OFFLINE(Online default)
EXTENT MANAGEMENT{[DICTIONARY]
[LOCAL default (AUTOALLOCATE/UNIFORM <INTEGERK/M>)]}
PERMANENT/TEMPORARY(Permanent default)
MINIMUM EXTENT
DEFAULT STORAGE {[INITIAL<INTEGERK/M>]
[NEXT <INTEGERK/M>]
[PCTINCREASE <INTEGERK/M>]
[MINEXTENTS <INTEGER>]
[MAXEXTENTS <INTEGER>/UNLIMITED]
[FREELISTS <INTEGER>]
[FREELISTSGROUPS <INTEGER>]
[OPTIMAL <INTEGER>/NULL]
[BUFFER_POOL <DEFAULT/KEEP/RECYCLE>]}
CHUNK <INTEGERK/M>
NOCACHE;
Página 41 de 135
Y, a continuación, creamos el usuario relacionado con la tabla de espacios anterior:
CÓDIGO
-- Ejemplo
CREATE USER ilerna IDENTIFIED BY 'root'
DEFAULT TABLESPACE ejercicios;
10.1.2. Administración de usuarios en MySQL

• Cuentas reservadas
MySQL posee algunas cuentas predefinidas o reservadas que vienen por defecto al
instalar el SGBD de MySQL. Son las siguientes:
- ROOT: cuenta que tiene todos los privilegios en el SGBD. Puede realizar
cualquier operación. Por motivos de seguridad, es posible cambiar el
nombre de ROOT por otro diferente, dada la gran cantidad de privilegios
que posee esta cuenta y lo llamativo del nombre ROOT que puede
resultar para un usuario malintencionado
- MYSQL.SYS: se usa para definir objetos del esquema sys (vistas,
procedimientos, funciones, etc.). Esta cuenta soluciona el problema en el
caso de que la cuenta ROOT fuese eliminada. Esta cuenta está protegida,
de modo que no acepta conexiones desde clientes
- MYSQL.SESSION: cuenta usada internamente por plugins (aplicaciones
de extensión, complementos) para acceder al servidor. Esta cuenta está
protegida, de modo que no acepta conexiones desde clientes
Página 42 de 135
• Privilegios administrativos
En MySQL existen tres privilegios administrativos que son los siguientes:
- Privilegios de administrador: permite al usuario realizar acciones en el
servidor MySQL de manera global, es decir, en cualquier BD contenida en
el servidor.
- Privilegios de una BD: son aquellos que atañen a una BD y todos los
objetos que hubiese dentro de dicha BD, tales como tablas, índices,
vistas, etc.
- Privilegios de objetos: son los privilegios que se aplican a objetos
concretos de una BD, tales como tablas, rutinas, vistas, etc.
• Creación de usuarios
Existen dos formas diferentes de un usuario: mediante la interfaz gráfica de
Workbench y mediante comandos.
1. Mediante la interfaz gráfica.
Imagen 3.2.a
Debemos hacer clic en Users and Privileges, de modo que aparecerá la pestaña de
usuarios y privilegios con la lista de los usuarios existentes. Para crear uno nuevo
clicaremos en AddAccount, tal como se señala en la imagen 3.2.a.
Página 43 de 135
Imagen 3.2.b
Al hacer clic en Add account se nos abrirán las pestañas de especificación del nuevo
usuario. En ellas podemos asignar el nombre de usuario, tipo de autentificación,
contraseña, privilegios, restricciones de acceso, etcétera.
2. Mediante comandos
Para crear un usuario nuevo en MySQL por medio de comandos podemos utilizar
CREATE USER.
CÓDIGO
-- Sintaxis
CREATE USER nombre_usuario IDENTIFIED BY 'password';
CÓDIGO
-- Ejemplo
CREATE USER 'mrobinson'@'localhost' IDENTIFIED BY 'mypassword123';
Página 44 de 135
En nuestro ejemplo, creamos un usuario sin especificar ninguna característica, de

modo que MySQL asigna dichas características por defecto. Sin embargo, la sintaxis
completa de CREATE USER puede ser mucho más extensa. La sintaxis completa de
CREATE USER es la siguiente:
CÓDIGO
-- Sintaxis
CREATE USER[ IF NOT EXISTS]
user [auth_option] [, user [auth_option]] …
[REQUIRE {NONE|tls_option[[AND]tls_option]…}]
[WITH resource_option [ resource_option ] … ]
[password_option | Lock_option] …
Para ver todas las opciones se puede consultar el manual MySQL (en inglés) en su
página web oficial:
https://dev.mysql.com/doc/refman/8.0/en/create-user.html
• Modificación de usuario
Para modificar una cuenta de usuario en MySQL usamos el comando ALTER USER.
Este comando pueden ejecutarlo solo los usuarios con privilegios de administrador
en su cuenta o también los que tengan el privilegio del comando UPDATE.
Para listar los usuarios existentes en el sistema y ver qué privilegios tiene cada uno
podemos utilizar la siguiente sentencia:
CÓDIGO
SELECT * FROM mysql.user;
Página 45 de 135
Al realizar dicha sentencia, MySQL Workbench nos informará de las cuentas de

usuario existentes y sus privilegios, como se observa en la imagen siguiente.
Imagen 3.2.c
Cuando usamos el comando ALTER USER modificamos las propiedades de una

cuenta de usuario, de modo que aquellas propiedades que no se especifiquen en la
sentencia mantendrán los valores que tenían asignados anteriormente.
CÓDIGO
-- Sintaxis
ALTER USER[ IF EXISTS ]
User [auth_option] [, user [auth_option]] …
[REQUIRE {NONE | tls_option [[AND] tls_option… }]
[WITH resource_option [resource_option] …]
[password_option | Lock_option ] …
Con la siguiente sentencia actualizaremos la contraseña de una cuenta de usuario

concreto.
CÓDIGO
-- Ejemplo
ALTER USER 'mrobinson'@'localhost' IDENTIFIED BY 'newpassword456';
Si además queremos fijar el requisito de que el usuario tenga que

establecer una contraseña nueva cada 200 días, además de otro tipo de
autentificación, lo expresaremos a través de la siguiente sentencia.
Página 46 de 135
CÓDIGO
-- Ejemplo
ALTER USER 'mrobinson'@'localhost' IDENTIFIED WITH sha256_password BY
'new_password' PASSWORD EXPIRE INTERVAL 200 DAY;
• Borrado de usuario
En MySQL la sentencia DROP USER se utiliza para eliminar un usuario junto con sus
privilegios. Su sintaxis es la siguiente.
CÓDIGO
-- Sintaxis
DROP USER [IF EXISTS] ‘nombre_usuario’@ ‘dominio_usuario’;
Como se puede observar en el código, el nombre del usuario y su dominio debe

estar entrecomillado y con una @ entre ambos.
Para que un usuario borre otro usuario, el primero debe tener el privilegio de crear
usuarios (CREATE USER) o el de eliminarlos (DELETE USER).
En versiones de MySQL anteriores a la 5.0.2 el comando DROP USER solo permite
borrar usuarios que no tengan privilegios asociados, pero en las versiones de
MySQL 5.0.2 y posteriores sí es posible.
Si realizamos un DROP USER sobre una cuenta de usuario que en ese instante está
abierta, la sentencia no se hará efectiva hasta que la sesión del usuario a borrar se
haya cerrado. Una vez se haya cerrado dicha sesión, la cuenta se eliminará y, por
tanto, no se podrá abrir más veces la sesión con esa cuenta de usuario.
A continuación, vemos un ejemplo de borrado de un usuario.
CÓDIGO
-- Sintaxis
DROP USER ‘mrobinson’ @ ‘localhost’;
Página 47 de 135
10.2. Administración de privilegios
Los privilegios son aquellos permisos y derechos que poseen los usuarios de una BD
que les permiten manipular los objetos que haya en la BD. Es decir, los privilegios
representan las opciones que se les han asignado a los usuarios de una determinada
BD para realizar acciones cómo:
• Ejecutar un tipo de sentencia SQL
• Acceder a un objeto de otro usuario
• Ejecutar distintos procedimientos
Los privilegios permiten jerarquizar el uso de una BD, de manera que nos
aseguramos de que solo los usuarios adecuados puedan modificar ciertos
elementos delicados de la BD. De esta manera ganamos seguridad en la BD.
Los privilegios se pueden asignar a los usuarios de manera explícita o también se
pueden asignar por medio de roles, que veremos más adelante.
10.2.1. Administración de privilegios en Oracle

En Oracle podemos diferenciar entre dos tipos de privilegios:
• Privilegios de sistema: ofrecen la posibilidad de realizar determinadas
acciones de administración en la BD, en cualquier esquema. Afecta a todos
los usuarios. Por ejemplo, CREATE USER o CREATE TABLE
• Privilegios de objetos: ofrecen a un usuario la posibilidad de acceder,
manipular o ejecutar objetos concretos (tablas, vistas, secuencias,
procedimientos, funciones o paquetes). Por ejemplo, borrar o consultar filas
de una tabla concreta
Al igual que en otros SGBD, el comando que asigna los privilegios en Oracle es
GRANT. De la misma forma que se le pueden asignar privilegios, usando el comando
REVOKE se le pueden denegar.
Página 48 de 135
Para asignar privilegios, la sintaxis del comando GRANT es:
CÓDIGO
-- Sintaxis
GRANT tipo_privilegio[(columna)][,tipo_privilegio[(columna)]…
ON {nombre_tabla|*|*.*|base_datos.nombre_tabla}
TO usuario [IDENTIFIED BY [PASSWORD]‘password’]]…
[WITH option[,opción]…
CÓDIGO
GRANT OPTION
|MAX_QUERIES_PER_HOUR count
|MAX_UPDATES_PER_HOUR count
|MAX_CONNECTIONS_PER_HOUR count
|MAX_USER_CONNECTIONS count
En este caso:
o tipo_privilegio: es el tipo de permiso que se le asigna al usuario (select,
insert, update, etc.)
o Los objetos sobre los que puede operar el usuario y los privilegios que se le
pueden aplicar se muestran en las siguientes expresiones:
- nombre_tabla sobre la tabla nombre_tabla.
- * sobre todas las tablas de la BD que se está utilizando.
- *.* sobre todas las tablas de todas las BBDD.
- Base_datos.* sobre todas las tablas de la BD base_datos.
- Base_datos.nombre_tabla sobre la tabla nombre_tabla que
pertenece a la BD base_datos.
o TO: indica el usuario al que se quiere otorgar el permiso. Si este no existe, se
crea con el password indicado mediante la cláusula IDENTIFIED BY.
Página 49 de 135
o WITH permite indicar ciertas opciones:
Expresión Función
GRANT OPTION Concede a otros usuarios los permisos que tiene el

primer usuario.
MAX_QUERIES_PER_HOUR Restringe el número de consultas por hora que

count puede realizar un usuario.
MAX_UPDATES_PER_HOUR Restringe el número de modificaciones por hora

count que puede realizar un usuario.
MAX_CONNECTIONS_PER_HOUR Restringe las conexiones por hora que realice un

count usuario.
MAX_USER_CONNECTIOS count Limita el número de conexiones simultáneas que

puede tener un usuario.
• Tipos de privilegios
Privilegio Significado
ALL Da todos los permisos simples excepto GRANT OPTION
ALTER Permite el uso de ALTER TABLE
ALTER ROUTINE Modifica o borra rutinas almacenadas
CREATE Permite el uso de CREATE TABLE
CREATE ROUTINE Crea rutinas almacenadas
CREATE TEMPORARY TABLES Permite el uso de CREATE TEMPORARY TABLE
CREATE USER Permite el uso de CREATE USER, DROP USER, RENAME USER
y REVOKE
CREATE VIEW Permite el uso de CREATE VIEW
Página 50 de 135
DELETE Permite el uso de DELETE
DROP Permite el uso de DROP TABLE
EXECUTE Permite al usuario ejecutar rutinas almacenadas
FILE Permite el uso de SELECT, INTO OUTFILE y LOAD DATA INFILE
INDEX Permite el uso de CREATE INDEX y DROP INDEX
INSERT Permite el uso de INSERT
LOCK TABLES Permite el uso de LOCK TABLES en tablas para las que tenga
el permiso SELECT
PROCESS Permite el uso de SHOW FULL PROCESSLIST
RELOAD Permite el uso de FLUSH
REPLICATION CLIENT Permite al usuario preguntar dónde están los servidores

maestros o esclavos
REPLICATION SLAVE Necesario para los esclavos de replicación
SELECT Permite el uso de SELECT
SHOW DATABASES Muestra todas las BBDD
SHOW VIEW Permite el uso de SHOW CREATE VIEW
SHUTDOWN Permite el uso demysqladmin shutdown
UPDATE Permite el uso de UPDATE
USAGE Sinónimo de no privileges, permite únicamente la conexión

al gestor
GRANTOPTION Posibilita dar permisos
Página 51 de 135
Veamos algunos ejemplos de concesión de permisos:

- Si deseamos que el usuario ilerna@localhost solo pueda seleccionar las
columnas nombreCliente, apellido y dirección, procederemos a ejecutar la
siguiente sentencia:
CÓDIGO
-- Ejemplo
GRANT SELECT(Nombre, Apellido, Dirección) ON alumnos TO ilerna@localhost;
'/home/oracle/oradata/orcl/ejercicios.dbf 'SIZE 1000M autoextend on;
- Si deseamos otorgar permisos de select a todas las tablas de todas las BBDD,
permitiendo al usuario ceder esos permisos a otros usuarios
CÓDIGO
-- Ejemplo
GRANT SELECTON *.* TO ilerna@localhost WITH GRANT OPTION;
'/home/oracle/oradata/orcl/ejercicios.dbf 'SIZE 1000M autoextend on;
Con esta instrucción damos el derecho indicado sobre la tabla que señalemos al
usuario citado. La última cláusula, que es opcional, permite al usuario que se le
conceda el permiso y la posibilidad de ceder el permiso a otra persona.
El DBA (Data Base Administrator) tendrá todos los permisos con la cláusula ALL,
tanto para concederlos como para revocarlos.
CÓDIGO
-- Ejemplo
REVOKE ALL PRIVILEGES ON *.* FROM ilerna@localhost
Página 52 de 135
10.2.2. Administración de privilegios en MySQL

En MySQL podemos distinguir entre los siguientes privilegios:
• Privilegios de administrador: estos privilegios permiten a un usuario realizar
cualquier acción sobre el servidor MySQL. Son privilegios de carácter global,
es decir, no atañen a una BD concreta.
• Privilegios de la BD: estos privilegios atañen a una BD concreta, por tanto,
permiten a un usuario realizar cambios en la BD especificada.
• Privilegios para objetos: estos privilegios permiten al usuario manipular
tablas, vistas, índices y rutinas almacenadas que haya en una BD.
En MySQL, al igual que en otros SGBD, el comando para asignar privilegios es

GRANT y para eliminarlos es REVOKE. Veamos la sintaxis simplificada del comando
GRANT.
CÓDIGO
-- Sintaxis simplificada
GRANT tipo_privilegio ON [tipo_de_objeto] nivel_de_privilegio TO usuario
A continuación, vamos a desglosar las opciones para cada variable en esta sintaxis.
Página 53 de 135
Tipo de privilegio
Los tipos de privilegios son múltiples. Podemos listar algunos en la siguiente tabla:
Privilegio Significado
ALL [PRIVILEGES] Concede todos los privilegios a excepción de GRANT

OPTION y PROXY.
ALTER Permite el uso de ALTER TABLE. A nivel global, de BD y de

tabla.
ALTER ROUTINE Modificar o borrar rutinas almacenadas. A nivel global, de

BD y de rutina.
CREATE Permite crear tablas y BBDD. A nivel global, de BD y tabla.
CREATE ROLE Permite la creación de un ROL a nivel global.
CREATE ROUTINE Permite crear rutinas almacenadas a nivel global o de BD.
CREATE USER Permite el uso de CREATE USER, DROP USER, RENAME

USER y REVOKE ALL PRIVILEGES a nivel global.
CREATE VIEW Permite crear y modificar vistas. A nivel global, de BD o de

tabla.
DELETE Permite el uso de DELETE. A nivel global, de BD o de tabla.
DROP Permite borrar BBDD, tablas o vistas. A nivel global, de BD

o de tabla.
EXECUTE Permite al usuario ejecutar rutinas almacenadas. A nivel

global, de BBDD y de rutina.
FILE Permite al usuario leer o escribir archivos del servidor a

nivel global.
GRANT OPTION Concede el privilegio de conceder o quitar privilegios a

otros usuarios. Niveles: global, BBDD, rutina, tabla y proxy.
Página 54 de 135
INSERT Permite el uso del comando INSERT. A nivel global, de BD,

de columna y de tabla.
LOCK TABLES Permite el uso de LOCK TABLES en tablas para las que
tenga el permiso SELECT. A nivel global y de BD.
PROCESS Permite al usuario observar todos los procesos (SHOW

PROCESSLIST) a nivel global.
RELOAD Permite el uso de FLUSH a nivel global.
REFERENCES Permite al usuario la creación de claves ajenas. A nivel

global, de BD, de tabla y de columna.
SELECT Permite el uso de SELECT. A nivel global, de BD, de tabla y

de columna.
SHOW DATABASES Permite ver todas las BBDD (SHOW DATABASES) a nivel
global.
SHOW VIEW Permite el uso del SHOW CREATE VIEW. A nivel global, de
BD y de tabla.
TRIGGER Permite las operaciones de disparadores (triggers). A nivel

global, de BD y de tabla.
UPDATE Permite el uso de UPDATE. A nivel global, de BD, de tabla y

de columna.
Nota: es posible consultar la tabla completa con todos los tipos de privilegios en la
documentación oficial de MySQL vía web.
https://dev.mysql.com/doc/refman/8.0/en/grant.html#grant-privileges
Página 55 de 135
Tipo de objeto
Los tipos de objetos sobre los que se les puede poner privilegios son:
Tabla (TABLE): refiere a las tablas de una BD
• Función (FUNCTION): es un bloque con nombre que puede estar

almacenado en la BD y puede ser llamado para ejecutar diferentes acciones.
• Procedimiento (PROCEDURE): es un bloque de instrucciones que se pueden
llamar por un nombre específico.
Nivel de privilegio
Los niveles de privilegio posibles son los siguientes:
Expresión El permiso se aplica a:
Nombre_tabla La tabla “Nombre_tabla”
* A todas las tablas de la BD en uso
*.* Todas las tablas de todas las BBDD
Base_datos.* Todas las tablas de la BD Base_datos
Base_datos.Nombre_tabla Solamente a la tabla Nombre_tabla de la

BBDD Base_datos
Página 56 de 135
Tipo de usuario
Con el comando GRANT, los tipos de usuario que pueden establecerse en la

concesión de privilegios son:
• Nombre de una cuenta de usuario (USER)
• Nombre de un rol (ROLE)
Para finalizar, con TO y especificando el nombre de usuario, se indica el permiso que

se otorgará al usuario.
Un ejemplo de uso de concesión de privilegios a un usuario podría ser el siguiente:
si quisiéramos darle la opción a la cuenta de usuario mrobinson, la opción de operar
con los comandos SELECT y INSERT en todos los objetos de la BD de municipio,
realizaríamos la siguiente sentencia:
CÓDIGO
-- Ejemplo
GRANT SELECT, INSERT ON municipio.* TO 'mrobinson'@'localhost';
Para eliminar los privilegios otorgados usamos el comando REVOKE.
CÓDIGO
-- Ejemplo
REVOKE ALL ON municipio.* FROM 'mrobinson'@'localhost';
Página 57 de 135
10.3. Administración de roles
Un rol es un grupo de privilegios a los que se asigna un nombre. El empleo de roles

facilita la administración, de forma que no hace falta especificar uno a uno los
privilegios que se conceden a cada nuevo usuario. Basta con asignarle un rol para
que herede todos los privilegios de este. Entre sus principales características,
podemos destacar:
• Se puede otorgar a cualquier usuario o rol, pero no a sí mismo, ni de forma
circular
• Puede tener contraseña
• Posee un nombre único en la BD
• No forma parte de ningún esquema
Trabajar con roles ofrece una serie de beneficios que, a continuación, vamos a
señalar:
• Simplifican el manejo de privilegios. Se pueden asignar diferentes permisos a
un rol y este también puede ser asignado a distintos usuarios
• Maneja los privilegios de forma dinámica, es decir, si se modifican los
privilegios asociados al rol se actualizan dichos privilegios en todos los
usuarios que lo posean de manera inmediata
• Disponibilidad selectiva de privilegios. Los roles asignados a un usuario
pueden ser activados o desactivados temporalmente y se pueden proteger
con clave
• El uso de roles disminuye el número de GRANT almacenados en el
diccionario de datos, por lo que mejora la productividad
Oracle proporciona roles predefinidos para ayudar a la administración de las BBDD.

Son los siguientes:
• CONNECT: incluye únicamente el privilegio CREATE SESSION, que permite
conectar a la BD. Si el usuario se crea con OEM, este rol se asigna
automáticamente.
• RESOURCE: incluye CREATE CLUSTER, CREATE INDEXTYPE, CREATE
OPERATOR, CREATE PROCEDURE, CREATE SEQUENCE, CREATE TABLE,
CREATE TIGGER y CREATE TYPE. Además, otorga el privilegio UNLIMITED
TABLESPACE.
Página 58 de 135
• DBA: incluye todos los privilegios del sistema mediante la opción WITH
ADMIN OPTION.
o No incluye arrancar o parar la BD.
o SYS y SYSTEM lo poseen.
Las definiciones de los roles están almacenadas en el diccionario de datos.

Normalmente se crea un rol y a posteriori se le asignan privilegios. Así, el grupo de
usuarios pertenecientes a este rol adoptan sus privilegios.
Veamos un ejemplo en el que primero nos creamos un rol y, a continuación, le
asignamos permisos para que estos los adquieran un grupo de usuarios.
CÓDIGO
-- Ejemplo
CREATE ROLE rol_ilerna;
GRANT CREATE ANY TABLE,
DROP TABLE,
INSERT ON Alumnos TO rol_ilerna;
GRANT rol_ilerna TO ilerna;
10.4. Administración de perfiles
Los perfiles no se manejan en todos los sistemas gestores de BBDD. En el caso de

Oracle, sí. En el de MySQL también, pero solo en versiones anteriores, porque en las
últimas han caído en desuso.
Los perfiles definen un conjunto de límites de recursos de la BD y del sistema
operativo para los distintos usuarios. Existe un perfil por defecto llamado DEFAULT
que tiene todos los recursos asignados con valor UNLIMITED. Este perfil se asigna
por defecto, a no ser que se especifique uno distinto. Cada usuario tiene
únicamente un perfil en un instante de tiempo determinado.
Página 59 de 135
Necesita el privilegio del sistema CREATE PROFILE, cuya sintaxis es:
CÓDIGO
-- Sintaxis
CREATE PROFILE <nombrePerfil> LIMIT
<parámetro 1><valor>|UNLIMITED|DEFAULT
<parámetro N><valor>|UNLIMITED|DEFAULT;
En la posición de parámetro podemos asignar parámetros sobre recursos o

parámetros sobre la contraseña. Algunos de los parámetros que podemos
determinar sobre los recursos son:
• SESSIONS_PER_USER: se determina cuántas sesiones simultáneas activas

puede tener un perfil, como máximo
• CPU_PER_SESSION: se determina el máximo de tiempo de CPU para una
sesión. Se expresa en centésimas de segundo
• CPU_PER_CALL: se determina un tiempo límite de respuesta para realizar
una llamada (en centésimas de segundo)
• CONNECT_TIME: se determina el tiempo máximo que puede estar activa
una sesión. Se expresa en minutos
• IDLE_TIME: Se determina el tiempo máximo de inactividad en una sesión
(minutos)
• LOGICAL_READS_PER_SESSION: Determina el número máximo de bloques
de datos leídos en una determinada sesión
• LOGICAL_READS_PER_CALL: Determina el número máximo de bloques
leídos en una llamada
Página 60 de 135
Algunos de los parámetros que podemos determinar sobre los recursos son los
siguientes:
• FAILED_LOGIN_ATTEMPTS: determina el número de intentos fallidos para
iniciar sesión en una cuenta. Si se supera la cuenta se bloqueará. Por defecto
el valor es de 10 intentos
• PASSWORD_LIFE_TIME: determina el número de días que una contraseña
puede ser usada para iniciar sesión. Por defecto son 180 días
En la posición de valor pondremos el valor del parámetro que hayamos asignado.

Se asigna el valor UNLIMITED si es un parámetro de recurso que se puede usar una
cantidad de veces ilimitada. Esto suele darse en el caso de parámetros que tienen
asignada una contraseña que no ha fijado límites. En cambio, el valor DEFAULT se
utiliza cuando queremos omitir algún parámetro asignado a un usuario por defecto.
10.5. Normativa legal vigente sobre la protección de datos
La Ley Orgánica 15/1999 de 13 de diciembre de Protección de Datos de Carácter

Personal (LOPD) tiene como objetivo garantizar y proteger en todo lo relativo a los
datos personales, las libertades públicas y los derechos fundamentales de las
personas físicas y especialmente su honor, intimidad y privacidad personal y
familiar.
Regula el tratamiento que se realiza de los datos de carácter personal, excluyendo
los datos recogidos para uso doméstico, las materias clasificadas del estado y
aquellos ficheros que recogen datos clasificados sobre terrorismo y otras formas de
delincuencia organizada.
En el ámbito estatal, la organización encargada del cumplimiento de dicha orden es
la Agencia Española de Protección de Datos (AEPD).
En el siguiente enlace podemos acceder al BOE para descargarnos dicha ley y poder
estudiarla más detenidamente: Ley Orgánica de Protección de Datos (LOPD).
Página 61 de 135
11. Programación en bases de datos (BBDD)
Cuando hablamos de programación en BBDD, debemos nombrar PL/SQL

(Procedural Language/ Structure Query Language) que es el lenguaje procesal
diseñado para poder trabajar junto con SQL. Está incluido en Oracle Database
Server. A continuación, detallaremos sus principales características:
• Integrado con SQL
• Control de errores y excepciones
• Uso de variables
• Estructuras de control de flujo
• Soporta Programación Orientada a Objetos (POO)
• Programación modular: procedimientos y funciones
11.1. Entornos de desarrollo al entorno de las BBDD
En informática, un intérprete de comandos es una aplicación que dispone de una

interfaz de usuario a través de la cual es posible enviar órdenes al sistema. Los
intérpretes de comandos tienen una sintaxis establecida que el usuario debe
conocer para poder gestionar dichas órdenes al sistema.
Los SGBD también poseen su propio intérprete de comandos, por los que se pueden
enviar consultas al servidor y los resultados son mostrados por la misma pantalla
del propio intérprete.
Por ende, tanto Oracle como MySQL también tienen sus propios intérpretes de
comandos. En el caso de Oracle disponemos de Oracle SQL * Plus y en MySQL nos
ofrece MySQL Command Line Client.
Respecto a SQL * Plus, es posible invocarlo desde el sistema operativo, ejecutando
el siguiente comando:
CÓDIGO
-- Sintaxis
Sqlplus [{usuario[/password][@database] | / |/nolog }] [AS {SYSDBA | SYSOPER}]
Página 62 de 135
Intérprete de comandos Oracle SQL * Plus.
Por otro lado, en MySQL disponemos de MySQL Command Line, el cual tiene un
comando de ayuda muy útil, help, que nos lista aquellos comandos que el mismo
intérprete ejecuta por sí mismo. Es decir, comandos auxiliares de la aplicación,
independientemente del servidor. Son útiles para salir del intérprete, cambiar de
BD, ejecutar un script y otras funciones.
Intérprete de comandos de MySQL.
Página 63 de 135
11.2. Sintaxis del lenguaje de programación
11.2.1. Bloques en PL/SQL

Los bloques son la forma más básica de programar en PL/SQL. Son fragmentos de
código que no se almacenan en la estructura de la BD y para ejecutarlo solo es
necesario introducirlos en la consola como si se tratase de SQL. Un bloque lógico
está estructurado en tres partes:
1. Parte de declaraciones(opcional): declararemos todas las variables,
constantes, cursores y excepciones definidas por el usuario.
2. Parte ejecutable (requerida): podremos hacer uso de las sentencias de
control que ofrecen los lenguajes de programación:
• Secuencias, órdenes del lenguaje, asignaciones, llamadas a

funciones o procedimientos, etc. Se colocarán una detrás de otra y
las separaremos con punto y coma (;).
• La iteración o bucle repetirá una sentencia o secuencia de
sentencias mientras se cumpla o hasta que deje de cumplirse una
condición.
3. Parte de tratamiento de excepciones (opcional): bloque opcional de

código donde podremos tratar los posibles errores que genere la parte
ejecutable del código.
CÓDIGO
-- Sintaxis
[DECLARE ]
-- declaraciones de objetos (variables, cursores, excepciones definidas
-- por el usuario)]
BEGIN/*comienza la parte ejecutable*/
-- comandos y sentencias SQL y PL/SQL
[EXCEPTION/*comienza la parte de tratamiento de excepciones */
-- acciones para realizar cuando se producen errores]
END;
/ -- fin de sentencia en consola de comandos
Página 64 de 135
En el caso de estar ejecutando el código por la consola de SQL, el símbolo / nos

cierra el bloque de código y este se ejecuta. En caso de no ponerlo, la consola se
queda esperando más líneas de código.
Este símbolo también lo utilizaremos en el caso de lanzar dos bloques distintos de
código en el SQL Developer. Por ejemplo, al lanzar dos creates juntos tendríamos
que separar los bloques ejecutables con el símbolo /.
Un bloque PL/SQL puede ser un bloque anónimo, un procedimiento o una función.

El objetivo de diseño PL/SQL es conseguir modularidad, es decir, simplificar la
complejidad del problema dividiéndolo en problemas más sencillos y fáciles de
implementar. Para ello se utilizan procedimientos y funciones.
11.2.2. Variables
Al igual que en otros los lenguajes de programación, los lenguajes diseñados para
las BBDD también usan variables. Las variables reservan en la memoria un espacio
para asignar valores concretos y se caracterizan por tener un tipo de información
determinado como pueden ser una fecha, una cadena de texto, un valor numérico,
etc.
Variables en PL/SQL
En cuanto al uso, las variables se declaran y se pueden inicializar en la sección
declarativa de un bloque PL/SQL. Permite pasar valores a un subprograma PL/SQL
mediante parámetros. Existen tres formas:
• IN: el valor viene del proceso de llamada. Es un dato de entrada y su valor no
se cambia. Es el valor por defecto
• OUT: en una salida de programa sin error, el valor del argumento devuelve
al proceso de llamada
• IN OUT: es una variable de entrada/salida
La sintaxis para la declaración de variables es:
CÓDIGO
-- Sintaxis
nombre_variable[CONSTANT] tipo_dato[NOTNULL][:=|DEFAULT|expresión ];
Página 65 de 135
CONSTANT declara la variable como constante. Su valor no puede cambiar. Debe

ser inicializada.
Los tipos de datos de las variables PL/SQL son:
• Compuesto: los tipos compuestos son las tablas, registros, tablas anidadas y
arrays.
• LOB: los tipos de datos LOB permiten almacenar bloques de datos no
estructurados como gráficos, imágenes, vídeos y texto de hasta cuatro
gigabytes de tamaño.
Escalar:
Tipo
BINARY-INTEGER Almacena enteros con signo.

Subtipos: NATURAL, POSITIVO
NUMBER[(precisión, Almacena números con punto fijo o flotante.

escala)]
CHAR[(longitud, Almacena cadenas de caracteres de longitud fija.

máxima)]
VARCHAR2(longitud, Almacena cadenas de caracteres de longitud variable.

máxima)
LONG Almacena cadenas de caracteres de longitud variable, tamaño

máximo 2 Gb.
RAW Almacena objetos binarios.
LONG RAW Almacena objetos binarios de hasta 2 Gb.
BOOLEAN Almacena TRUE, FALSE o NULL.
DATE Almacena valores de fecha.
ROWID Dirección física de una fila de la BDD.
Página 66 de 135
Existen otras variables que no son PL/SQL y podemos clasificar en:

• Variables BIND
• Variables HOST
Variables en MySQL
En MySQL debemos diferenciar bien entre las palabras clave y las variables. Una
palabra clave (keyword) es una palabra que ya posee un significado predefinido en
MySQL, como pueden ser BEGIN, SELECT, CREATE, etcétera.
Además, las keyword pueden ser reservadas o no. La diferencia entre el manejo de
una palabra clave reservada y una que no lo es pasa por tener que poner comillas
en el caso de que sea reservada. De tal modo que, si en MySQL queremos crear una
tabla con una palabra reservada escribiremos lo siguiente:
CÓDIGO con ERROR
-- Ejemplo
CREATE TABLE select (id INT, comentarioVARCHAR(100)); X
La sentencia nos dará error y nos aparecerá el siguiente mensaje:
MENSAJE de ERROR
ERROR 1064 You have an error in your SQL syntax; check the manual that corresponds to
your MySQL server version for the right syntax to use near 'select (id INT, comentario
VARCHAR(100))' at line 1
Sin embargo, al utilizar las comillas simples el sistema ejecuta la sentencia

perfectamente:
CÓDIGO
-- Ejemplo
CREATE TABLE `select` (id INT, comentarioVARCHAR(100));
Página 67 de 135
Por otro lado, en MySQL tenemos las variables de usuario, que pueden emplearse
para guardar determinados valores y utilizarlos posteriormente. La sintaxis para
declarar una variable es la siguiente:
CÓDIGO
-- Sintaxis
SET @nombre_de_variable= expresión;
Por ejemplo, vamos a establecer que la variable mínimo tiene un valor de un millón
(1000000):
CÓDIGO
-- Ejemplo
SET @minimo =1000000;
De este modo, si tuviéramos una tabla llamada población con la siguiente

información:
Resultado de una sentencia select en el entorno Workbench.
Para mostrar solo las ciudades que tienen un mínimo de población de un millón de
habitantes, podríamos utilizar la variable mínimo anteriormente declarada:
CÓDIGO
-- Ejemplo
SELECT * FROM poblacion WHERE cantidad > @minimo;
Página 68 de 135
Y nos devolvería lo siguiente:
Resultado de otra sentencia select en el entorno Workbench.
11.2.3. Operadores
Los operadores sirven para relacionar variables entre sí, cuya combinación dará
lugar a expresiones aportando resultados. Siendo de esta forma un fundamento de
la lógica en la programación de BBDD. Las operaciones que se pueden realizar son
las siguientes:
OPERADOR ACCIÓN
** Potencia
+ - (unarios) Signo positivo o negativo
* Multiplicación
/ División
+ Suma
- Resta
|| Concatenar cadenas
=, <, >, <= Comparaciones: igual, menor que, mayor que, menor o igual que,
>=,<>, != mayor o igual que, distinto que, distinto que
IS NULL, LIKE Es nulo, como
BETWEEN, IN Entre, en
NOT Negación lógica de un booleano

AND Operador AND lógico entre tipos de datos booleanos
OR Operador OR lógico entre tipos de datos booleanos
Página 69 de 135
A continuación, se muestra una tabla con ejemplos de expresiones verdaderas

(TRUE) utilizando los operadores anteriores:
(3 + 5) / 2 = 4 6+4/2=5
5 != 3 0 <> NULL
5 IS NOT NULL == TRUE 5 BETWEEN 2 AND 10
‘Alumno’ LIKE ‘%u%’ 6 IN (2,4,6)
‘a’ NOT IN (‘d’,’e’) (1<4) AND (5>=5)
En la programación estructurada se debe hacer uso de distintos tipos de estructuras

de control. Las describiremos a continuación.
• Selección: este tipo de estructuras ejecutan un conjunto de instrucciones
dependiendo de si se cumple o no una determinada condición.
• Sentencia IF: evalúa una expresión y en función de si el valor de esta es
verdadero o falso se ejecutan unas instrucciones u otras.
CÓDIGO
-- Sintaxis
IF condición THEN
instrucciones;
[ELSIF condición THEN
instrucciones;]
[ELSE
instrucciones;]
ENDIF;
/
Nota: el contenido de la sintaxis que está entre corchetes […] indica que es
opcional incluirlo en el código. Por tanto, no es obligatorio poner ELSE o
ELSIF en una sentencia IF.
Página 70 de 135
EJEMPLO
-- Sintaxis
IF dept = “Administración” THEN
numero:=numero*2;
ELSIF dept = “Secretaría” THEN
numero:=numero*1.5;
ELSE
numero:=numero*1.1;
ENF IF;-- Solamente es necesario un END IF
• Sentencia CASE: evalúa un conjunto de condiciones hasta encontrar alguna

que se cumpla y ejecuta las instrucciones que esta tiene asociadas.
CÓDIGO
-- Sintaxis
CASE [expresión]
WHEN {condición1|valor1 } THEN
bloque_instrucciones_1
WHEN {condición2|valor2 } THEN
bloque_instrucciones_2
ELSE
bloque_instrucciones_por_defecto
END CASE;
/
Página 71 de 135
EJEMPLO:
-- Sintaxis
SELECT Nombre, CASE EC
WHEN ‘C’ THEN ‘Casado/a’
WHEN ‘S’ THEN ‘Soltero/a’
WHEN ‘D’ THEN ‘Divorciado/a’
ELSE ‘Otros’
END
AS “Estado civil”
FROM Empleados;
• Iteración: consiste en la repetición de un conjunto de instrucciones un

número determinado de veces. A continuación, se describen distintos tipos
de estructuras de iteración.
o Estructura repetitiva básica:
CÓDIGO
-- Sintaxis
LOOP
sentencias;
END LOOP;
/
Página 72 de 135
En estos ejemplos de bucles vamos a utilizar la sentencia

dbms_output.put_line para ver los valores de la variable cont por
pantalla, de tal forma que nos ayude a entender mejor las condiciones
de salida de los bucles. Para que esta sentencia funcione correctamente
tenemos que lanzar la sentencia SET SERVEROUTPUT ON, que activa el
visionado de los mensajes por consola.
Estas sentencias vienen explicadas en el punto 4.5 de cursores y
transacciones en el apartado de Herramientas de depuración y control
de código.
En esta unidad formativa también encontraremos algunas funciones de
Oracle, las cuales harán referencia a la fecha, al identificador de la fila,
etc.
Por ejemplo: Sysdate: fecha diaria
Rowid: identificador de la fila
User: usuario del sistema de BD
NLS_Session_Parameters: parámetros de sesión
DUAL: tabla del sistema donde encontramos la fecha y otros
parámetros
Este bucle estará repitiéndose infinitamente, ya que no existe ninguna condición

que permita salir de él. Es conveniente evaluar si dentro del bucle existe alguna
condición que provoque la salida de este. Podemos realizarlo de dos formas:
Página 73 de 135
1. Usando WHEN: saliéndonos del bucle cuando se cumpla cierta condición,

mediante la cláusula EXIT.
CÓDIGO
-- Ejemplo
SET SERVEROUTPUT ON;

DECLARE
CONT INT:=0;
BEGIN
LOOP
CONT:=CONT+1;
EXIT WHEN CONT>=10;
END LOOP;
END;
2. Usando IF: forzando a salir de la iteración mediante EXIT.
CÓDIGO
-- Ejemplo
DECLARE
CONT INT :=0;
BEGIN
LOOP
CONT :=CONT +1;
IFCONT >=10 THEN
EXIT;
END IF;
END LOOP;
/
Página 74 de 135
o Esquema WHILE
CÓDIGO
-- Sintaxis
WHILE condición LOOP
instrucciones;
END LOOP;
/
o Esquema FOR: este bucle solo lo podemos usar cuando conocemos de

antemano el número de repeticiones o iteraciones que queremos realizar.
CÓDIGO
-- Sintaxis
FOR índice IN [REVERSE] valor_inicial .. valor_final
LOOP
instrucciones;
END LOOP;
/
En este caso:
- Índice no hace falta declararlo ya que lo hace implícitamente al usar la
estructura FOR, pero no se puede usar fuera de ella.
- REVERSE recorre el bucle en sentido inverso, es decir, va decrementando el
valor de índice.
Página 75 de 135
Vamos a ver algunos ejemplos muy sencillos de cómo utilizar las sentencias de
iteración que acabamos de ver:
CÓDIGO
-- Ejemplo de iteración WHILE

DECLARE
cont INTEGER :=0;
fin BOOLEAN :=TRUE;

BEGIN
WHILE finLOOP
cont := cont + 1;
dbms_output.put_line(cont);
IFcont>=5 THEN
fin := FALSE;
cont :=0;
END IF;
END LOOP;
END;
Página 76 de 135
CÓDIGO
-- Ejemplo de iteración FOR

DECLARE
cont INTEGER :=0;
calc INTEGER :=0;

BEGIN
FOR cont IN 0 .. 5
LOOP
calc := cont * 5;
dbms_output.put_line(calc);
END LOOP;
END;
/
11.3. Procedimientos y funciones
Los procedimientos y funciones son herramientas que poseen lenguajes de BBDD

como PL/SQL o MySQL y nos permiten reutilizar un código determinado todas las
veces que necesitemos utilizarlo.
La definición de un procedimiento o función tienen dos partes:
• Especificación: se declara el nombre del subprograma. Esta declaración está
formada por el nombre y los tipos de los argumentos. Si hablamos de
funciones y, solo en este caso, también se indicará el valor devuelto
• Cuerpo: formado por sentencias PL/SQL que realizarán el objetivo para el
cual se creó el procedimiento o la función
Página 77 de 135
Procedimientos en PL/SQL
Los procedimientos en PL/SQL están formados por un conjunto de sentencias que
se van a ejecutar cada vez que el procedimiento se invoque, por ejemplo, desde un
bloque. Cuando un procedimiento es creado se compilará y se almacenará en la BD
para su posterior invocación.
A continuación mostramos la sintaxis de un procedimiento en PL/SQL:
CÓDIGO
-- Sintaxis
CREATE [ORREPLACE]PROCEDURE [esquema ].nombre_procedure
(nombre_parametro {IN|OUT|INOUT} tipo_de_dato,…)
{IS|AS}
declaraciones_de_variables;
declaraciones_de_constantes;
declaraciones_de_cursores;
BEGIN
cuerpo_del_subprograma;
[EXCEPTION
bloque_de_excepciones; ]
END;
/
Página 78 de 135
En este caso:
• CREATE [OR REPLACE] PROCEDURE crea el procedimiento. Si se usa
REPLACE se asegura que, si existiera ya ese procedimiento, lo reemplace o
sustituya
• nombre_procedure indica el nombre del procedimiento
• Parámetro formal: nombre del parámetro definido en la función, donde
funcionan como variables locales con la particularidad de que se inician con
el valor que tengan los parámetros actuales en el momento de llamarlo
• Parámetro actual: son los valores que tienen los parámetros cuando se
llama a la función. Es el valor que se asignan en la invocación a los
parámetros formales
• Parámetros para utilizar en la ejecución del procedimiento:
- IN: valor por defecto. El parámetro es de entrada. Cualquier modificación
realizada en el procedimiento no afectará a su valor fuera del
procedimiento. El parámetro actual no puede cambiar
- OUT: el parámetro es de salida, es decir, en el procedimiento se le va a
asignar un valor y este va a afectar al parámetro actual, pero no sirve
para pasar un valor al procedimiento a través del parámetro formal
- IN OUT: el parámetro se usa tanto para entrada como para salida
- IS | AS: no existe diferencia entre las dos, podemos poner la que
deseemos
- Declaraciones de variables, constantes y cursores
- Entre BEGIN y END escribiremos el cuerpo del procedimiento
Procedimientos en MySQL
Al igual que en PL/SQL, un procedimiento en MySQL está formado por una
declaración y un cuerpo que contiene sentencias SQL. El procedimiento puede ser
invocado tantas veces como sea necesario.
Los procedimientos suelen ser muy útiles, ya no solo por la posibilidad de
reutilización y, por tanto, eficiencia en el código, sino por la seguridad que ofrecen.
Un procedimiento permite modificar de manera controlada una información
sensible en la BD a usuarios que en principio tienen pocos privilegios. De este modo,
los usuarios podrán ejecutar dichas sentencias, pero no podrán modificarlas.
Página 79 de 135
A continuación mostramos la sintaxis de un procedimiento en MySQL:
CÓDIGO
-- Sintaxis
CREATE PROCEDURE
nombreProc ( [IN | OUT | INOUT] nombre_parametro, tipo)
[características]
BEGIN
Sentencias SQL;
END;
En este caso:
• CREATE PROCEDURE crea el procedimiento
• nombreProc es el nombre del procedimiento
• nombreParam es el nombre que damos al parámetro de entrada
• las características son opcionales
• tipo es el tipo de dato del parámetro de entrada
• Entre BEGIN y END escribiremos el cuerpo del procedimiento
Veamos un ejemplo:
CÓDIGO
-- Ejemplo
DELIMITER $$
CREATE PROCEDURE mostrar_poblacion (IN codigo INT)
BEGIN
SELECT * FROM poblacion WHERE id = codigo;
END$$
Página 80 de 135
La sentencia DELIMITER se utiliza para cambiar el punto y coma (;) como

delimitador de sentencia, de modo que podamos enviar al servidor toda la
definición como una sola sentencia. Para llamar al procedimiento utilizamos el
comando CALL:
CÓDIGO
-- Ejemplo
CALL $$mostrar población (3);
Funciones
Una función está formada por un conjunto de sentencias que se van a ejecutar cada
vez que esta se invoque. Esta definición coincide con la de procedimiento, ¿en qué
se diferencian? La función va a devolver siempre un resultado que será un tipo de
datos concreto que ha sido definido en su declaración.
Para devolver dicho valor se usará la palabra reservada RETURN. Así, deberá
aparecer al menos una vez a lo largo del código.
CÓDIGO
-- Sintaxis
CREATE [ OR REPLACE ] FUNCTION [ esquema ].nombre_función
( nombre_parámetro tipo_de_dato, … )
RETURN tipo_de_dato
{ IS | AS }
declaraciones_de_variables;
declaraciones_de_constantes;
declaraciones_de_cursores;
BEGIN
cuerpo_del_subprograma;
[ EXCEPTION
bloque_de_excepciones;]
END;
/
Página 81 de 135
En este caso:
• Tipo_de_dato: indicaremos el tipo de dato que se va a devolver. Podemos
realizar la llamada a los procedimientos o funciones que hemos creado de
varias formas.
CÓDIGO
-- Sintaxis
EXECUTE nombre_procedimiento;
CALL nombre_procedimiento();
--Podemos ejecutar el procedimiento dentro de un bloque
BEGIN
nombre_procedimiento [ (Parametros) ];
END;
/
A continuación, vamos a ver unos ejemplos para ilustrar el trabajo con

procedimientos y funciones.
Página 82 de 135
CÓDIGO
-- Ejemplo
CREATE OR REPLACE PROCEDURE mensaje
IS
BEGIN
dbms_output.put_line('¿Cómo estás? Este es un mensaje de prueba');
END;
/
-- Para ejecutar el procedimiento
EXECUTE mensaje;
CÓDIGO
-- Ejemplo
CREATE OR REPLACE PROCEDURE duplicarEntero (num IN OUT INT)
AS
BEGIN
num :=2* num;
END;
DECLARE
i int:=5;
BEGIN
duplicarEntero(i);
dbms_output.put_line(i);
END;
/
Página 83 de 135
CÓDIGO
-- Ejemplo
CREATE OR REPLACE FUNCTION Paridad(entero INT)
RETURN VARCHAR2--Devuelve si el número proporcionado es par o no
IS
esPar VARCHAR2(15);
BEGIN
IF MOD(entero,2)=0THEN
esPar:='Es par';
ELSE
esPar:='No es par';
ENDIF;
RETURN(esPar);
END;
BEGIN
dbms_output.put_line(Paridad(1));
END;
/
Página 84 de 135
CÓDIGO
-- Ejemplo
CREATE OR REPLACE FUNCTION unm2mes(unm INT)
RETURN VARCHAR2–Devuelve el mes
IS
mes VARCHAR2(20);
BEGIN
CASE num
WHEN 1 THEN mes :='Enero';
WHEN 2 THEN mes :='Febrero';
WHEN 3 THEN mes :='Marzo';
WHEN 4 THEN mes :='Abril';
WHEN 5 THEN mes :='Mayo';
WHEN 6 THEN mes :='Junio';
WHEN 7 THEN mes :='Julio';
WHEN 8 THEN mes :='Agosto';
WHEN 9 THEN mes :='Septiembre';
WHEN 10 THEN mes :='Octubre';
WHEN 11 THEN mes :='Noviembre';
WHEN 12 THEN mes :='Diciembre';
ELSE mes :='Error';
END CASE;
RETURN(mes);
END;
/
Página 85 de 135
11.4. Control de errores
Una excepción es el resultado que se obtiene tras ejecutar un bloque PL/SQL que
posee un error. La llamada al tratamiento de excepciones puede producirse de dos
formas:
• Ocurre un error y la excepción se lanza de forma automática.
• La lanzamos nosotros de forma explícita usando la sentencia RAISE.
1.
CÓDIGO
-- Sintaxis
EXCEPTION
WHEN exception1 [ or exception2 … ]THEN
sentencias_para_ejecutar;
WHEN exception3 [ or exception4 … ]THEN
WHEN OTHERS THEN
END;
/
Tipos
Podemos clasificarlas en:
• Excepciones Oracle predefinidas: Oracle las lanza de forma automática. Son
excepciones estándar predefinidas a las que se ha dado nombre.
Página 86 de 135
Nombre Descripción
NO_DATA_FOUND La sentencia SELECT no devuelve ningún valor.
TOO_MANY_ROWS La sentencia SELECT devuelve más de una fila.
INVALID_CURSOR Se está haciendo referencia a un cursor no válido.
ZERO_DIVIDE Se está intentando realizar una división de un número entre

cero.
CASE_NOT_FOUND Ninguna de las condiciones de la sentencia WHEN en la

estructura CASE se corresponde con el valor evaluado y no
existe cláusula ELSE.
CURSOR_ALREADY_OPEN El cursor que intenta abrirse ya está abierto.
INVALID_NUMBER La conversión de una cadena a valor numérico no es posible

porque la cadena no representa un valor numérico válido.
VALUE_ERROR
VALUE_ERROR Error ocurrido en alguna operación aritmética, de

conversión o trucado.
LOGIN_DENIED Un programa está intentado acceder a la BD con un usuario

o password incorrecto.
NOT_LOGGED_ON Un programa está intentado ejecutar una acción en la BD sin

haber formalizado previamente la conexión.
TIMEOUT_ON_RESOURCE Se ha acabado el tiempo que el SGBD pude esperar por

algún recurso.
OTHERS Es la opción por defecto. Interceptará todos los errores no

tenidos en cuenta en las condiciones WHEN anteriores.
Página 87 de 135
Por ejemplo:
CÓDIGO
-- Ejemplo
DECLARE
identificador NUMBER;
BEGIN
SELECT nombre INTO identificador

FROM Alumno
WHERE cod = 100;
EXCEPTION
WHEN NO_DATA_FOUND OR TOO_MANY_ROWS THEN
DBMS_OUTPUT.PUT_LINE ('El error es: '|| SQLCODE );
DBMS_OUTPUT.PUT_LINE ( SQLERRM );
END;
• Excepciones Oracle NO-predefinidas: si se declaran en la sección declarativa

pueden ser tratadas por Oracle de forma automática. Se debe definir el código
Oracle asociado a esa excepción numérica. Para ello se utiliza la sentencia
PRAGMA EXCEPTION_INIT.
Página 88 de 135
Si estamos utilizando programas como SQL Developer, hay que tener en cuenta
que, cuando tenemos un error en el código, este nos muestra en la consola el
código del error, ya que hay tal cantidad de errores que memorizarlos es
imposible.
CÓDIGO
-- Ejemplo
DECLARE
fecha_incorrecta EXCEPTION;
PRAGMA EXCEPTION_INIT (fecha_incorrecta,-01847);
fecha DATE;
BEGIN
fecha:=TO_DATE('32-12-2017');
dbms_output.put_line(fecha);
EXCEPTION
WHEN fecha_incorrecta THEN
dbms_output.put_line('La fecha introducida es incorrecta');
END;
/
Página 89 de 135
• Errores definidos por el usuario: no tienen relación con Oracle. Son

condiciones que se determina que son errores. Se declaran en la sección
declarativa, pero es necesario tratarlas de forma explícita. Se lanza con la
sentencia RIASE:
CÓDIGO
-- Ejemplo
DECLARE
negativo EXCEPTION;
valor NUMBER;
BEGIN
valor:= -1;
IF valor< 0 THEN
RAISE negativo;
END IF;
EXCEPTION
WHEN negativo THEN
dbms_output.put_line('Números negativos NO permitidos');
END;
/
Página 90 de 135
11.5. Cursores y transacciones
Los cursores son las diferentes estructuras que nos permiten recorrer la salida de
una consulta realizada. PL/SQL utiliza cursores para gestionar las diferentes
instrucciones SELECT. Recordemos que un cursor es un conjunto de registros
devuelto por una instrucción SQL. Una definición más técnica para los cursores
podría hacer referencia a los fragmentos de memoria que tenemos reservados para
procesar los resultados de una consulta SELECT.
Debemos señalar los dos tipos de cursores que podemos tener:
• Implícitos: utilizados para operaciones SELECT INTO. Vamos a hacer uso de
ellos cuando la consulta devuelve un único registro
• Explícitos: estos son declarados y controlados por el programador cuando
una consulta devuelve un conjunto de registros. Aunque, algunas veces, se
utilizan en consultas que devuelven un único registro por razones de
eficiencia. Son más rápidos
Definimos los cursores de la misma forma que si fuera una variable de PL/SQL.
Aunque también es cierto que los cursores implícitos no necesitan declaración.
Los cursores explícitos son necesarios cuando vamos a procesar instrucciones
SELECT que devuelven más de una fila y/o atributos. En este caso, irán combinados
con una estructura de bloque.
Los cursores, además, pueden utilizar parámetros que se declaran junto con el
cursor.
• Cursores implícitos: los cursores implícitos se utilizan para realizar consultas

SELECT que devuelven un único registro. Para utilizarlos, debemos tener en
cuenta:
- Con cada cursor implícito debe existir la palabra clave INTO
- Las variables que reciben los datos devueltos por el cursor tienen que
contener el mismo tipo de dato que las columnas de la tabla
- Los cursores implícitos solo pueden devolver una única fila. En caso de que
se devuelva más de una fila (o ninguna fila) se producirá una excepción. Por
medio de PL/SQL gestionaremos los errores
Página 91 de 135
El siguiente ejemplo muestra un cursor implícito:
CÓDIGO
-- Ejemplo
DECLARE
vnombre VARCHAR2(50);
BEGIN
SELECT nombre INTO vnombre FROM Alumno WHERE codigo=14;
DBMS_OUTPUT.PUT_LINE('El nombre del alumno es : ' || vnombre);
END;
/
La salida del programa generaría la siguiente línea:
El nombre del alumno es: Juan.
o Excepciones asociadas a los cursores implícitos: los cursores implícitos

solo pueden devolver una fila, por lo que pueden producirse
determinadas excepciones. Las más comunes que se pueden encontrar
son no_data_foundy too_many_rows
Página 92 de 135
La siguiente tabla explica brevemente estas excepciones:
Excepción Explicación
NO_DATA_FOUND Se produce cuando una sentencia SELECT intenta recuperar

datos, pero ninguna fila satisface sus condiciones. Es decir,
cuando no hay datos.
TOO_MANY_ROWS Dado que cada cursor implícito solo es capaz de recuperar

una fila, esta excepción detecta la existencia de más de una
fila.
• Cursores explícitos en PL/ SQL: los cursores son áreas de memoria que
almacenan datos extraídos de la BD mediante una consulta SELECT o por
manipulación de datos con sentencias de actualización o inserción de datos.
La utilización de cursores es necesaria cuando:
- Se precisa tratamiento fila a fila.
- En sentencias SELECT que devuelven más de una fila.
El cursor debe ser declarado (en la zona DECLARE) antes de usarlo. Debe tener un
nombre y estar asociado a una consulta determinada.
CÓDIGO
-- Sintaxis
DECLARE
CURSOR nombre_cursor IS sentencia_SELECT;
Página 93 de 135
Entre las diferentes operaciones que se pueden realizar:

1. Open: para trabajar con un cursor debemos abrirlo e inicializarlo para que
devuelva las filas. Al hacer OPEN en el cursor ya se ejecuta la consulta y pone todas
las filas devueltas en el conjunto activo
CÓDIGO
-- Sintaxis
OPEN nombre_cursor;
2. Fetch: el cursor va a devolver la siguiente fila en el conjunto activo. Los datos

devueltos se almacenan en variables de control o en un registro. Vamos a realizar
esto haciendo uso de la orden FETCH
CÓDIGO
-- Sintaxis
FETCH nombre_cursor CURSOR INTO { [ var1, varN ] | nombre_registro };
Cada vez que se realiza un FETCH, el cursor avanza a la siguiente fila recuperada,
por lo que es necesario comprobar los atributos del cursor para ver si el cursor
tiene filas o ya ha llegado al final.
Se debe recorrer el cursor hasta encontrar la información que interese o hasta
que no haya más filas. También es necesario usar un bucle para repetir estas
acciones hasta conseguir el resultado buscado.
Un bucle de cursor FOR de forma implícita:
• Declara una variable REGISTRO de tipo ROWTYPE
• Abre el cursor
• De forma repetitiva realiza el FETCH de las filas sobre la variable
registro
• Cierra el cursor cuando todas las filas han sido procesadas
Página 94 de 135
3. Close: para finalizar debemos cerrar el cursor. Conseguimos así desactivarlo y

liberar la memoria que ocupaban los datos recuperados por este al abrirlo
CÓDIGO
-- Sintaxis
CLOSE nombre_cursor;
Existe un número limitado de cursores que pueden estar abiertos a la vez en la BD.
Además, una vez cerrado no es posible recuperar datos hasta que no se abra de
nuevo.
Para declarar un cursor debemos emplear la siguiente sintaxis:
CÓDIGO
-- Sintaxis
DECLARE CURSOR nombre_cursor IS <consulta_SELECT>;
BEGIN
OPEN nombre_cursor;-- Abrir el cursor
FETCH nombre_cursor INTO VARIABLES_PLSQL --Recorrer el cursor
CLOSE nombre_cursor ;-- Cerrar el cursor
END;
/
Página 95 de 135
También podemos declarar los posibles parámetros que necesite el cursor:
CÓDIGO
-- Sintaxis
DECLARE CURSOR nombre_cursor (parametro1 tipo1, parametro2
tipo2 parametro3 tipo3, …. ) IS <consulta>;
BEGIN
OPEN nombre_cursor;-- Abrir el cursor
FETCH nombre_cursor INTO VARIABLES_PLSQL --Recorrer el cursor
CLOSE nombre_cursor ;-- Cerrar el cursor
END;
/
Los cursores implícitos no se pueden manipular por el usuario, pero Oracle sí

permite el uso de sus atributos:
nombre_cursor %atributo_deseado;
Los atributos pueden ser:
Atributo Significado
Devuelve un valor booleano: TRUE si está abierto el cursor o FALSE si está

%ISOPEN
cerrado.
Devuelve un valor booleano: TRUE si tras la recuperación más reciente no se

%NOTFOUND
recuperó ninguna fila.
Devuelve un valor booleano: TRUE si tras la recuperación más reciente se

%FOUND
recuperó una fila.
%ROWCOUNT Retorna el número de filas devueltas hasta el momento.
Página 96 de 135
Cuando trabajamos con cursores debemos considerar una serie de aspectos:

• Cuando un cursor está cerrado no se puede leer
• Cuando leemos un cursor debemos comprobar el resultado de la lectura
utilizando los atributos de los cursores
• Cuando se cierra el cursor es ilegal tratar de usarlo
• Es ilegal tratar de cerrar un cursor que ya está cerrado o no ha sido abierto
Los atributos de los cursores pueden tomar los valores TRUE, FALSE o NULL,
dependiendo de la situación:
Antes de Durante la Al finalizar la Después de

Atributo Al abrir
abrir recuperación recuperación cerrar
%NOTFOUND ORA-1001 NULL FALSE TRUE ORA-1001
%FOUND ORA-1001 NULL TRUE FALSE ORA-1001
%ISOPEN FALSE TRUE TRUE TRUE FALSE
%ROWCOUNT ORA-1001 0 * ** ORA-1001
* Número de registros que ha recuperado hasta el momento.
** Número total de registros.
Página 97 de 135
Por medio de ciclo LOOP podemos iterar a través del cursor. Debemos tener
cuidado al agregar una condición para salir del bucle. Vamos a ver varias formas de
iterar a través de un cursor. La primera es utilizando un bucle LOOP con una
sentencia EXIT condicionada:
CÓDIGO
-- Sintaxis
OPEN nombre_cursor;
LOOP
FETCH nombre_cursor INTO lista_variables;
EXIT WHEN nombre_cursor %NOTFOUND;
/* Procesamiento de los registros recuperados */
END LOOP;
CLOSE nombre_cursor;
/
A continuación, vamos a ver un ejemplo donde se ilustra el trabajo con un cursor

explícito. Debemos tener en cuenta que, al leer los datos del cursor, hay que
hacerlo sobre variables que sean del mismo tipo de datos de la tabla o tablas de las
que trata el cursor. Tendremos que crear un bucle para recorrer los distintos
registros que nos puede devolver la consulta.
Página 98 de 135
CÓDIGO
-- Ejemplo
DECLARE
CURSOR calumno
IS
SELECT nombre, apellidos
FROM Alumnos;
vnombre VARCHAR2(50);
vapellidos VARCHAR2(50);
BEGIN
OPEN calumno;
LOOP
FETCH calumno INTO vnombre, vapellidos;
EXIT WHEN calumno %NOTFOUND;
dbms_output.put_line('Nombre: ' || vnombre || ' apellido: ' || vapellidos);
END LOOP;
CLOSE calumno;
END;
/
Podemos simplificar el ejemplo, utilizando un atributo del tipo %ROWTYPE sobre

el cursor y cambiar el bucle de iteración de registros para ver distintas formas de
realizar un mismo ejemplo.
Página 99 de 135
CÓDIGO
-- Ejemplo
DECLARE
CURSOR calumno
IS
SELECT nombre, apellidos
FROM Alumnos;
registro calumno %ROWTYPE;
BEGIN
OPEN calumno;
FETCH calumno INTO registro;
WHILE calumno %FOUND LOOP
dbms_output.put_line('Nombre: ' || registro.nombre
|| ' apellido: ' || registro.apellidos);
FETCH calumno INTO registro;
END LOOP;
CLOSE calumno;
END;
/
• Cursores de actualización: se declaran de la misma forma que los explícitos,

añadiendo FOR UPDATE al final de la sentencia SELECT
CÓDIGO
-- Sintaxis
CURSOR nombre_cursor IS
instrucción_SELECT
FOR UPDATE [OF column_list] [NO WAIT]
Página 100 de 135

Para actualizar los datos del cursor ejecutamos la sentencia UPDATE y

especificamos la cláusula WHERE CURRENT OF <cursor_name>.
CÓDIGO
-- Sintaxis
UPDATE <nombre_tabla> SET
<campo_1> = <valor_1>
[,<campo_2> = <valor_2>]
WHERE CURRENT OF <cursor_name>
Al trabajar con cursores de actualización se debe tener en cuenta que generan

bloqueos en la BD. A continuación, vamos a ver un ejemplo de cómo utilizar los
cursores de actualización.
CÓDIGO
-- Ejemplo
DECLARE
CURSOR calumno IS
SELECT nombre
FROM alumnos
FOR UPDATE;
vnombreVARCHAR2(50);
BEGIN
dbms_output.put_line('Valores antes de actualizarse');
OPEN calumno;
FETCH calumno INTO vnombre;
Página 101 de 135

WHILE calumno %found LOOP

dbms_output.put_line('Nombre: '|| vnombre;);
UPDATE alumnos
SET nombre=nombre||'.'
WHERE CURRENT OF calumno;
END LOOP;
CLOSE calumno;
COMMIT;
dbms_output.put_line('');
dbms_output.put_line('Valores después de actualizarse');
OPEN calumno;
FETCH calumno INTO vTitulo,iAno,vProtagonista;
WHILE calumno %found LOOP
dbms_output.put_line('Nombre: '||vnombre;);
END LOOP;
CLOSE calumno;
END;
/
Sobre las herramientas de depuración y control de código hay que indicar que
PL/SQL no está pensado para interactuar directamente con un usuario final. Por
este motivo, carece de instrucciones especializadas en la entrada y salida, teclado y
pantalla.
Existen algunos métodos que nos permiten mostrar el resultado de lo que se está
haciendo por pantalla, así como poder asignar valores a las variables desde teclado
para ir probando cómo se comportan los programas con distintos valores en las
variables, sin necesidad de ir modificando el código en cada caso.
Página 102 de 135

• La salida: debemos activar la variable SERVEROUTPUT de Oracle. Solo

tendremos que hacerlo una vez:
CÓDIGO
-- Sintaxis
Tras su activación, se pueden mostrar textos, variables y constantes en pantalla

usando la siguiente instrucción:
CÓDIGO
-- Sintaxis
DBMS_OUTPUT.PUT_LINE( cadena_de_salida );
CÓDIGO
-- Ejemplos
-- Texto
DBMS_OUTPUT.PUT_LINE('hola');
-- Variables
DBMS_OUTPUT.PUT_LINE( nombre_variable );
-- Constantes
DBMS_OUTPUT.PUT_LINE( sysdate);
-- Combinaciones
DBMS_OUTPUT.PUT_LINE('cadena de texto ' || contador || sysdate );
Página 103 de 135

• La entrada: la forma de leer valores desde teclado y conseguir asignarlos a

una variable, consiste en utilizar el símbolo & seguido del mensaje que se
visualizará al pedir la entrada del valor.
Este mensaje debe ser una cadena de caracteres sin espacios en blanco. Para
separar las palabras del mensaje se recomienda hacerlo con guiones bajos.
Este tipo de recogida de valores se realizará al iniciar la ejecución del
procedimiento, independientemente del lugar donde se realice la petición
dentro del código.
Entrada de valores a variables por teclado:
CÓDIGO
-- Sintaxis
nombreVariable := &Texto_para_mostrar;
Por ejemplo:
CÓDIGO
-- Ejemplo
DECLARE
Lado INT;
BEGIN
-- Introducir lado del cuadrado para calcular su área
Lado := &INTRODUCE_EL_VALOR_DEL_LADO_DEL_CUADRADO;
DBMS_OUTPUT.PUT_LINE ('Un cuadrado de lado' || lado ||
' tiene un área de ' || Lado*Lado );
END;
/
Página 104 de 135

Al ejecutar este bloque nos solicitarán el lado del cuadrado:
11.6. Disparadores o triggers
Un trigger es un módulo PL/SQL compilado y almacenado en la BD que tiene

asociada una tabla y que se ejecuta al llevar a cabo una instrucción SQL. Van a ser
muy útiles cuando queramos:
• Forzar reglas de integridad que son difíciles de definir a partir de
constraints.
• Realizar cambios en la BD de forma transparente para el usuario.
• Sincronizar el mantenimiento de tablas duplicadas que están localizadas en
nodos distintos de una BD distribuida.
• Generar automáticamente valores de columnas derivadas en base a un
valor proporcionado por una sentencia.
Uno de los usos más frecuentes de los triggers es definir reglas y restricciones de
integridad de los datos que sean complejas. Es importante que los datos de una BD
estén sujetos a reglas de integridad predefinidas. Oracle permite definir y forzar que
se verifiquen las reglas de integridad declarando restricciones de integridad y
definiendo triggers.
Página 105 de 135

Una restricción de integridad es un método declarativo para definir una restricción

para una columna de una tabla. Oracle soporta:
1. Not Null: no admite valores nulos
2. Unique: solo admite valores únicos
3. Primary Key: clave primaria
4. Check: reglas complejas
5. Foreign Key: restricciones de integridad referencial
Aunque podemos definir y forzar cualquier tipo de regla de integridad, se

recomienda que solo se use en los siguientes casos:
• Definir acciones de integridad referencia que no se puedan forzar con
Foreign Key.
• Forzar reglas de integridad referencia si las tablas padre e hija están en
nodos distintos de una BD distribuida.
• Forzar reglas complejas que no se puedan definir con restricciones de
integridad.
CÓDIGO
-- Sintaxis
CREATE [ OR REPLACE ] TRIGGER nombre_trigger
[ BEFORE | AFTER ] [ DELETE | INSERT | UPDATE [ OF columnas ] ]
[ OR ] [ DELETE | INSERT | UPDATE [ OF columnas ] ] …]
ONtabla
[ FOR EACH ROW [ WHEN condición TRIGGER ] ]
[DECLARE ]
-- declaración de variables locales
BEGIN
-- Instrucciones de ejecución
[ EXCEPTION ]
-- instrucciones de excepción
END;
/
Página 106 de 135

En este caso:
- BEFORE | AFTER indica en qué momento queremos que se ejecute el trigger,
antes o después de la acción SQL:
o BEFORE: la usaremos cuando queremos revisar los cambios antes de que se
hagan efectivos sobre la tabla para poder modificarlos en caso de que
incumplan alguna restricción.
o AFTER: la usaremos en aquellos casos en los que se quiera consultar o
cambiar la tabla en cuestión, ya que los triggers solo pueden llevar a cabo
estas operaciones después de que los cambios iniciales son aplicados a la
tabla y esta se encuentra en un estado estable.
- DELETE | INSERT | UPDATE: acciones SQL que disparan el trigger.
- FOR EACH ROW: indicamos que el trigger se disparará por cada fila de la tabla
sobre la cual se lleva a cabo la operación SQL.
- WHEN: podemos incluir una condición de disparo del trigger.
- Cuerpo del programa: entre BEGIN y END se puede codificar cualquier orden de
consulta o manipulación de datos y llamadas a funciones o procedimientos,
como en cualquier código PL/SQL, respetando la integridad de la BD. No se
puede usar el control de transacciones COMMIT y ROLLBACK. Los
procedimientos y funciones a las que invoque el trigger deben cumplir también
las restricciones anteriores.
Un trigger puede dispararse por causa de más de una operación SQL. Podemos
utilizar los siguientes predicados condicionales:
- INSERTING: devuelve TRUE cuando el trigger ha sido disparado por una orden
INSERT.
- DELETING: devuelve TRUE cuando el trigger ha sido disparado por una orden
DELETE.
- UPDATING: devuelve TRUE cuando el trigger ha sido disparado por una orden
UPDATE.
- UPDATING (columna): devuelve TRUE cuando el trigger ha sido disparado por
una orden UPDATE y la columna ha sido modificada.
Página 107 de 135

Para hacer referencia en el código al valor nuevo o al valor viejo de las columnas
que estamos modificando, hacemos uso de las palabras reservadas OLD y NEW
siguiendo estas reglas:
- En las modificaciones de una fila, la referencia al valor antes de ser modificado
(:OLD) y al valor después de la modificación (:NEW).
- En la introducción de valores nuevos se hace referencia solo al valor nuevo
(:NEW).
- En los borrados de valores se hace referencia solo al valor antiguo (:OLD).
- En la condición WHEN de los triggers se deben utilizar quitando los dos puntos,
es decir, NEW y OLD.
Por ejemplo, para las siguientes tablas:
Página 108 de 135

- Trigger para validar las fechas de alta y de baja:
CÓDIGO
-- Ejemplo
CREATE OR REPLACE TRIGGER empleados_fechaBaja_fechaAlta
BEFORE INSERT OR UPDATE OF FechaAlta, FechaBaja ON EMPLEADO
FOR EACH ROW
BEGIN
IF (:new.FechaBaja IS NOT NULL) AND (:new.FechaBaja <= :new.FechaAlta)
THEN
RAISE_APPLICATION_ERROR (-20600, 'La fecha de la baja debe ser nula o mayor que la
fecha de alta');
END IF;
END;
-- Sentencia con la que haríamos saltar el error del trigger creado
INSERT INTO EMPLEADO (FechaAlta, FechaBaja)
VALUES ('10-05-2017', '08-05-2017');
/
Página 109 de 135

- Trigger para validar los empleados supervisados por el jefe:
CÓDIGO
-- Ejemplo
CREATE OR REPLACE TRIGGER empleado_supervisores
BEFORE INSERT OR UPDATE OF DNIjefe ON EMPLEADO
FOR EACH ROW
DECLARE
-- variable para contar los empleados subordinados
v_supervisados INTEGER;
BEGIN
SELECT count(*) INTO v_supervisados
FROM empleado WHERE DNIjefe= :new.DNIjefe;
-- cuenta los subordinados antes de actualizar o insertar
IF (v_supervisados >= 10 ) THEN
-- cuneta antes de la inserción o actualización del código jefe
RAISE_APPLICATION_ERROR (-20601, 'El jefe no puede supervisar a más de 10
empleados');
END IF;
END;
/
Página 110 de 135

12. Uso de las BBDD objeto-relacionales
Hasta ahora hemos trabajado con las BBDD relacionales. Estas poseen una serie de
normas y una estructura bien definida y algo rígida.
Sin embargo, existen otros tipos de modelos de BBDD más flexibles y versátiles,
como por ejemplo, las BBDD orientadas a objetos, las cuales están definidas en base
a diferentes objetos que poseen una serie de funcionalidades, con una filosofía
similar a la POO.
No obstante, existe un modelo híbrido, que es el que estudiamos en este tema: las
BBDD objeto-relacionales.
Las BBDD objeto-relacionales son como una extensión del modelo relacional que
hemos estado viendo. No utilizan parte de las reglas que antes sí usábamos, pero
por otro lado, añaden una nueva solución a la hora de modelar la información.
La mayor diferencia que existe entre las BBDD relacionales y las BBDD objeto-
relacionales es la existencia de tipos de objetos.
Los tipos se crean mediante sentencias ODL (Object Definition Language) y van a
ser la base del desarrollo de las BBDD objeto-relacionales.
Cuando tengamos que definir el modelo objeto-relacional añadiremos a las
características anteriores (entidades, relaciones, atributos y reglas) los tipos.
Tipos de objetos
Un tipo de objeto representa una entidad del mundo real que consta de las
siguientes partes:
• Un nombre que permite identificar el tipo objeto.
• Unos atributos que caracterizan el objeto.
• Unos métodos que definen las operaciones sobre los datos de ese tipo ya
definidos.
Página 111 de 135

12.1. Características
La principal característica que debemos destacar de las BBDD objeto-relacionales es

que combinan el modelo relacional con el modelo Orientado a Objetos, de tal modo
que evolucionan con la incorporación de algunos conceptos del modelo Orientado a
Objetos.
Por ejemplo, este tipo de BBDD permite la creación de nuevos tipos de datos
manteniendo todo lo que ya posee del modelo entidad-relación, como las
entidades, los atributos, las relaciones y las reglas.
En el modelo objeto-relacional, cada registro de una tabla se considera un objeto y
la definición de la tabla, su clase. Este modelo tiene capacidad para gestionar tipos
de datos complejos, lo cual contradice algunas de las restricciones establecidas por
el modelo relacional.
• Permite campos multivaluados, con lo cual, contradice frontalmente la 1FN
• Las tablas dejan de ser elementos bidimensionales para pasar a convertirse a

estructuras de datos bastante más complejas
Por ejemplo: una columna puede ser tipo Asignatura, conteniendo toda la
información de esta y no únicamente su clave ajena.
Página 112 de 135

• De la misma forma, también es posible que los valores que adopte un campo
sean registros de otra tabla, es decir, colecciones de objetos. Es lo que se
conoce como modelo relacional anidado.
Por otra parte, las BBDD relacionales se caracterizan porque se basan en una
Programación Orientada a Objetos (POO), que se desarrolla basándose en tres
elementos fundamentales: encapsulamiento, herencia y polimorfismo.
Encapsulamiento
Conocemos por encapsulamiento el mecanismo que vamos a seguir para agrupar
los atributos y métodos dentro de un nuevo concepto que denominamos clase.
Mediante el uso de clases podemos abstraer un tipo de objeto como un conjunto de
datos y acciones que están agrupadas.
Si utilizamos el encapsulamiento debemos tener definidos todos los métodos que
vayan a formar parte de las clases que intervengan. Estos métodos, deben
acompañar el objeto
Herencia
Una de las grandes ventajas de trabajar con objetos es la herencia, la cual permite
crear superclases abstractas para posteriormente utilizarlas para crear subclases
más específicas. Estas heredarán atributos y métodos de la superclase. Es decir,
podemos crear subclases de clases creadas anteriormente.
Página 113 de 135

Un ejemplo en el cual podemos apreciar de forma sencilla qué es la herencia es en

una escuela, donde nos podemos encontrar alumnos, profesores y empleados. La
característica en común que tienen es de una persona: nombre, identificador,
teléfono, edad, etc.
En el siguiente ejemplo se creará una superclase llamada persona que englobe los
atributos comunes de persona:
EJEMPLO
CREATE OR REPLACE TYPE persona AS OBJECT (

id NUMBER,
nombre VARCHAR2(20),
telefonoslistin)
NOT FINAL
/
Como se puede apreciar, se ha incluido la cláusula NOT FINAL. Esta nos indica que
este objeto permite que a través de él se generen más objetos.
Crearemos un objeto de persona que se extienda del objeto persona.
EJEMPLO
CREATE OR REPLACE TYPE estudiante UNDER persona (

nombre_escuela VARCHAR2(30),
nota_media NUMBER)
NOT FINAL
/
Página 114 de 135

En este ejemplo anterior, se puede observar que la cláusula UNDER especifica la

superclase a la cual pertenece estudiante. Se incluye NOT FINAL al final para poder
ampliar estas clasificaciones. Por ejemplo, un estudiante de intercambio:
EJEMPLO
CREATE OR REPLACE TYPE estudiante_int UNDER estudiante (

pais VARCHAR2(30),
nombre_escuela VARCHAR2(30))
/
Polimorfismo
Se utiliza el polimorfismo cuando una clase derivada debe verse como la clase
principal. Esto significa que se va a disponer de un objeto de una clase derivada,
pero nos vamos a referir a él como si fuera un objeto de una clase principal.
Además, nos permite ejecutar diversas funciones que han sido sustituidas, como
por ejemplo: overrided (sobrecargadas) o overwritten (sobrescritas). PL/SQL utiliza
la sobrecarga.
12.2. Tipos de datos objeto
Los objetos han conseguido entrar en el mundo de las BBDD en forma de dominios,
actuando como el tipo de datos de una columna determinada. A continuación,
vamos a ver dos implicaciones muy importantes que se producen por el hecho de
utilizar una clase como un dominio:
• Es posible almacenar múltiples valores en una columna de una misma fila, ya que
un objeto suele contener múltiples valores. Sin embargo, si se utiliza una clase
como dominio de una columna, en cada fila esa columna solo puede contener un
objeto de la clase (se sigue manteniendo la restricción del modelo relacional de
contener valores atómicos en la intersección de cada fila con cada columna).
Página 115 de 135

• Es posible almacenar procedimientos en las relaciones porque un objeto está

enlazado con el código de los procesos que sabe realizar (los métodos de su
clase).
Otro modo de incorporar objetos en las BBDD relacionales es construyendo tablas
de objetos, donde cada fila es un objeto.
Ya que un sistema objeto–relacional es un sistema relacional que permite
almacenar objetos en sus tablas, la BD sigue sujeta a las restricciones que se aplican
a todas las BBDD relacionales y conserva la capacidad de utilizar operaciones de
concatenación (JOIN).
Los usuarios pueden definir sus propios tipos de datos a partir de los tipos básicos
provistos por el sistema o por otros tipos de datos predefinidos anteriormente por
el usuario. Estos tipos de datos pueden pertenecer a dos categorías distintas:
objetos y colecciones.
12.3. Definición de tipos de objeto
En Oracle, los tipos de objeto son aquellos tipos de datos que han sido definidos por
el usuario. Los objetos se presentan de forma abstracta, almacenados en columnas
y tablas.
Para poder crear tipos de objeto se debe hacer uso de la sentencia CREATE TYPE.
Está compuesta por los siguientes elementos:
1. Un nombre para identificar los tipos de objeto
2. Unos atributos, que pueden ser de un tipo de datos básico o de un tipo
definido por el usuario, que representan la estructura y los valores de los
datos de ese tipo
3. Unos métodos que son procedimientos o funciones. Se declaran con la
cláusula MEMBER
Página 116 de 135

CÓDIGO
-- Ejemplo
CREATE OR REPLACE TYPE persona AS OBJECT (
teléfono VARCHAR2(20)
);
/
Se puede observar que cada objeto persona tendrá dos atributos: el nombre y el
teléfono. Vamos a ver, a continuación, la definición de un tipo de objeto:
CÓDIGO
-- Sintaxis
CREATE OR REPLACE TYPE nombreObjeto AS OBJECT(
atributo1 TIPO,
atributo2 TIPO,
atributoN TIPO,
MEMBER FUNCTION nombreFuncion1 RETURN TIPO,
MEMBER FUNCTION nombreFuncion2(nomVar TIPO) RETURN TIPO,
MEMBER PROCEDURE nombreProcedimiento
PRAGMA RESTRICT REFERENCES (nombreFuncion1, restricciones),
PRAGMA RESTRICT REFERENCES (nombreFuncion2, restricciones),
PRAGMA RESTRICT REFERENCES (nombreProcedimiento, restricciones)
);
/
Página 117 de 135

Un método miembro de un tipo de objeto debe cumplir las siguientes

características:
• No puede insertar, actualizar o borrar las tablas de la BD
• No se puede ejecutar en paralelo o remotamente si va a acceder a los
valores de una variable dentro de un módulo
• No puede modificar una variable de un módulo excepto si se invoca desde
una cláusula SELECT, VALUES o SET
• No puede invocar a otro módulo o subprograma que rompa alguna de las
reglas anteriores
La directiva PRAGMA_REFERENCES se utiliza para forzar las reglas anteriores.
CÓDIGO
-- Sintaxis
PRAGMA RESTRICT REFERENCES ({DEFAULT | método}, {RNDS, WNDS, RNPS, WNPS},
[RNDS, WNDS, RNPS, WNPS]});
Donde restricciones puede ser cualquiera de las siguientes o incluso una

combinación de ellas:
• WINDS: evita que el método pueda modificar las tablas de la BD
• RNDS: evita que el método pueda leer las tablas de la BD
• WNPS: evita que el método modifique variables del paquete PL/SQL
• RNPS: evita que el método pueda leer las variables del paquete PL/SQL
Página 118 de 135

Veamos ahora la definición del cuerpo de un objeto:
CÓDIGO
-- Sintaxis
CREATE OR REPLACE TYPE BODY nombreObjeto AS
MEMBER FUNCTION nombreFuncion
RETURN TIPO
IS
BEGIN
--Código de la función
END nombreFuncion;
MEMBER FUNCTION nombreFuncion2(nomVar TIPO)
RETURN TIPO
IS
BEGIN
--Código de la función 2
END nombreFuncion2;
MEMBER PROCEDURE nombreProcedimiento
IS
BEGIN
--Código del proceso
END nombreProcedimiento;
END;
/
Página 119 de 135

Por ejemplo:
CÓDIGO
-- Ejemplo Definición de clase

CREATE OR REPLACE TYPE Persona AS OBJECT(
idpersona NUMBER,
dni VARCHAR2(9),
apellidos VARCHAR2(30),
fecha_nac DATE,
MEMBER FUNCTION muestraEdad RETURN NUMBER,
PRAGMA RESTRICT_REFERENCES (muestraEdad, WNDS)
);
/
CÓDIGO
-- Ejemplo Cuerpo de clase

CREATE OR REPLACE TYPE BODY persona AS
MEMBER FUNCTION muestraEdad RETURN NUMBER
IS
BEGIN
RETURN to_char(sysdate,'YYYY')-to_char(fecha_nac,'YYYY');
END muestraEdad;
END;
/
Una vez que ya tenemos definida la clase y el cuerpo, podemos utilizar este objeto
como si de un tipo cualquiera se tratase.
Página 120 de 135

CÓDIGO
-- Ejemplo
DECLARE
Trabajador1 Persona;
BEGIN
Trabajador1:=NEW Persona(1,'123456','Alberto','Olivia',
'22/12/1989');
dbms_output.put_line('El empleado '|| Trabajador1.nombre
||' ha sido creado');
dbms_output.put_line('Edad del empleado: '
||Trabajador1.muestraEdad());
END;
/
Colecciones
Para poder contar con atributos multievaluados (1:N) es necesario que los
organicemos en una estructura de datos. Una estructura es conocida como array o
colección. Para crear un atributo de tipo array debemos usar la siguiente sintaxis.
CÓDIGO
-- Ejemplo
-- Lista de un tipo primitivo varchar2
CREATE TYPE colec_nombres AS VARRAY(10) OF VARCHAR2(20);
-- Lista de un tipo de usuario: Persona
CREATE TYPE colec_personas AS VARRAY(10) OF Persona;
Página 121 de 135

Una vez que ya hemos creado un tipo de colección, podemos utilizarla dentro de la
definición de una clase:
CÓDIGO
-- Ejemplo
CREATE OR REPLACE TYPE Departamento AS OBJECT(
NombreDept VARCHAR2(100),
Empleados colec_personas
);
/
Tablas derivadas de objetos

De la misma forma que creamos objetos haciendo uso de los tipos definidos,
también podemos hacerlo con las tablas:
CÓDIGO
-- Ejemplo
CREATE TABLE Empleados (
NombreDept VARCHAR2(50),
Datos_Empleado Persona
);
/
Para hacer un insert debemos indicar el tipo de objeto que estamos insertando:
CÓDIGO:
-- Ejemplo
INSERT INTO Empleados
VALUES('Informática', Persona(1, '1111', 'Paco', 'González', '23/12/1988'));
Página 122 de 135

12.4. Herencia
Una de las principales ventajas de la POO es la herencia. Gracias a la herencia se

pueden crear superclases abstractas para que, en adelante, se puedan crear
subclases más específicas que hereden atributos y métodos de las superclases.
En las BBDD objeto-relacionales se puede hacer algo parecido en lo que se refiere a
los tipos de objetos. Pueden crearse subtipos de objetos a partir de otros
supertipos de objetos que ya han sido creados con anterioridad.
El supertipo define los atributos o métodos que van a compartir con los subtipos,
todos los objetos que hereden de él. A parte de estos, los subtipos también pueden
definir sus propios atributos y métodos. También pueden redefinir los métodos del
supertipo para adoptarlo a sus necesidades. Este proceso se conoce como
polimorfismo.
Veamos, por ejemplo, desde el objeto general supertipo TIPO_PERSONA podemos
definir el subtipo TIPO_EMPLEADO que va a heredar las características de su
supertipo TIPO_PERSONA.
El tipo objeto especializado TIPO_EMPLEADO puede tener atributos adicionales o

incluso puede redefinir métodos del objeto padre TIPO_PERSONA ampliando la
funcionalidad de sus tipos objeto.
La cláusula NOT FINAL hace referencia a que este objeto no es el último. Es decir, cuando
creemos subtipos de objetos que cuelguen de este, tendremos que declarar el objeto
con esta cláusula. En el caso de no poner la cláusula al crear este objeto, cuando
queramos colgar otros objetos de este nos devolverá error, aunque nos compile el
objeto.
Página 123 de 135

Tipo persona
CÓDIGO
-- Ejemplo
CREATE TYPE tipo_person AS OBJECT (
fecha_nac DATE,
MEMBER FUNCTION edad RETURN NUMBER,
MEMBER FUNCTION printme RETURN VARCHAR2
) NOT FINAL;
Subtipo empleado: para crear un subtipo utilizamos la cláusula UNDER
CÓDIGO
-- Ejemplo
CREATE TYPE tipo_empleado UNDER tipo_person (
sueldo NUMBER,
MEMBER FUNCTION paga RETURN NUMBER,
OVERRIDING MEMBER FUNCTION printme RETURN VARCHAR2);
/
Heredamos los atributos y los métodos añadiendo características propias de

tipo_person y sobrescribimos el método printme.
Página 124 de 135

12.5. Identificadores, referencias
El tipo REF o referencia es un contenedor de un identificador de objeto (Object

Identifier –OID). Es un puntero a un objeto. Su utilidad se basa, principalmente, en
apuntar a un objeto que ya existe y así evitar tener que duplicar la información que
el objeto almacena.
Por ejemplo, si se desea crear una tabla de libros en la que cada libro tiene su autor
y esos autores ya están almacenados en una tabla de objetos, se podría hacer uso
de la palabra reservada REF para indicar que el autor ya existe y, por tanto, solo se
almacena una referencia a ese autor en la tabla de libros.
Con la palabra reservada DEREF, obtenemos el valor de un objeto al que apunta
dicha referencia.
CÓDIGO
-- Ejemplo
CREATE TYPE autor AS OBJECT (
id INTEGER,
nombre VARCHAR(100),
direccion VARCHAR(255)
);
/
CREATE TYPE libro AS OBJECT (
id INTEGER,
nombre VARCHAR(200),
escritor REF autor
);
/
Página 125 de 135

12.6. Tipos de datos colección
Los tipos para colecciones se definen para poder implementar relaciones 1:N. Un
dato de tipo colección está formado por un número indefinido de elementos, todos
del mismo tipo. Así, es posible almacenar un conjunto de tuplas en un único
atributo, en forma de array o de tabla anidada.
Los tipos para colecciones también tienen, por defecto, unas funciones
constructoras de colecciones, cuyo nombre coincide con el del tipo. Los argumentos
de entrada de estas funciones son el conjunto de elementos que forman la
colección separados por paréntesis.
Tipo Varray
Un array es un conjunto de elementos ordenados del mismo tipo. Todos los
elementos que lo componen poseen asociado un índice que indica la posición que
este ocupa dentro del array.
CÓDIGO
-- Ejemplo
CREATE TYPE colec_telefono AS VARRAY (10) OF VARCHAR2 (30);
Con esta instrucción definimos un nuevo tipo de datos llamado colec_telefono, que
va a tener como máximo grupos de 10 valores y, además, van a tener 30 caracteres
como máximo. Creamos la tabla para representar la siguiente estructura:
CÓDIGO
-- Ejemplo
CREATE TABLE alumno (
Id NUMBER,
Nombre VARCHAR2(20),
Telefonos colec_telefono
);
Página 126 de 135

ID Nombre Teléfonos
1 Carmen (955701212, 614785222)
2 Antonio (957842563, 645458523)
A la hora de insertar datos lo hacemos como en cualquier tabla:
CÓDIGO
-- Ejemplo
INSERT INTO alumno
VALUES (1, 'Carmen' colec_telefono ('955701212', '614785222'));
Podemos comprobar que es necesario especificar el tipo colec_telefono para que el

SGBD realice las comprobaciones necesarias.
Tablas anidadas
Una tabla es un conjunto de elementos del mismo tipo. Se diferencian del tipo
anterior porque en este tipo no existe un orden predefinido.
Las tablas anidadas poseen una serie de restricciones:
• Solo pueden tener una columna.
• El tipo de dato que almacena puede ser básico o definido por el usuario
Página 127 de 135

Si redefinimos nuestro ejemplo anterior, redefinimos el tipo alumnos de la siguiente

forma:
CÓDIGO
-- Ejemplo
CREATE TYPE tabla_telefono AS TABLE OF VARCHAR2 (30);
Creamos la tabla basándola en el tipo tabla_alumno:
CÓDIGO
-- Ejemplo
CREATE TABLE alumno (
id NUMBER,
nombre VARCHAR2 (20),
telefonos tabla_telefono)
NESTED TABLE telefonos STORE AS t_telefono;
Ahora la tabla_telefono ya no es un tipo colección, sino un tipo tabla.

Las columnas que son tablas anidadas junto con los atributos que son tablas de
objetos necesitan de una tabla independiente donde almacenar las filas de dichas
tablas. Para especificar esta tabla se utiliza la cláusula NESTED TABLE...STORE AS....
Para consultar, insertar, borrar o actualizar información en tablas anidadas se puede
hacer igual que con las colecciones.
Página 128 de 135

12.7. Declaración e inicialización de objetos
Para declarar un objeto en la BD Oracle tenemos que crear un nuevo tipo de datos.
Podemos hacerlo de dos formas diferentes:
• Mediante SQL Developer podemos

conectarnos a una BD ya creada en
Oracle y, a partir de ahí, seleccionar
Types en el panel de conexiones
• De una forma más directa, utilizando la instrucción CREATE TYPE, cuya sintaxis
es:
CÓDIGO
-- Sintaxis
CREATE[OR REPLACE] TYPE[schema.] type_name
[OID'object_identifier']
[object_type
| | {IS|AS} {varray_type_def | nested_table_type_def}
];
Página 129 de 135

De forma que la definición de object_type se corresponde con:
CÓDIGO
-- Sintaxis
[inviker_rights_clause]
{{IS|AS} OBJECT
| UNDER [schema.]supertupe
}[sqlj_object_type]
[({attribute datatype [ sqlj_object_type_attr]}…
[, element_spec [, element_spec]…]
)
][[NOT]FINAL] [ [NOT] INSTANTIABLE]
Si nos basamos en SQL Developer, el programa nos genera de forma automática la

estructura básica para la creación de un objeto. Aunque dentro de la misma
tenemos que definir las propiedades principales del objeto en cuestión, como
podemos apreciar en el siguiente código:
CÓDIGO
-- Creación y asignación de propiedades

CREATE OR REPLACE TYPE OBJPRODUCTO AS OBJECT
(
codigo varchar2(20), nombre varchar2(60), familia varchar2(60),
altura float, anchura float, longitude float, peso float, color varchar2(20),
precioCompra float, precioVenta float, fechaCr date
);
/
Página 130 de 135

12.8. Sentencia SELECT. Inserción, modificación y borrado de objetos
Inserción
Cuando tengamos que insertar objetos en una tabla, utilizaremos el comando

INSERT:
CÓDIGO
-- Ejemplo
BEGIN
INSERT INTO person
VALUES('Juan', 'Mata');
END;
/
Aunque también tenemos la posibilidad de utilizar el constructor para el objeto en

cuestión:
CÓDIGO
-- Ejemplo
BEGIN
INSERT INTO person
VALUES(Person ('Juan', 'Mata'));
END;
/
Página 131 de 135

A continuación, vamos a ver un script con la tabla relacional departamento. Tiene

una columna tipo person y va a insertar una fila en esa tabla:
CÓDIGO
-- Ejemplo
CREATE TABLE departamento (
dept_nombre VARCHAR2(20),
jefe_dept Person,
localidad VARCHAR2(20)
);
-- Inserción de datos
INSERT INTO departamento
VALUES('Contabilidad', Person ('Adrián', 'Tormo'), 'Lleida');
--Consultamos el tipo de dato

SELECT departamento.person.apellido FROM departamento;
Modificación
A la hora de modificar atributos de un objeto determinado en una tabla de objetos
vamos a utilizar la sentencia UPDATE. Por ejemplo:
CÓDIGO
-- Ejemplo
BEGIN
UPDATE person p SET p. direccion = 'c/larga, 7'
WHERE p. apellido = 'López';
UPDATE person p SET p = Person ('Eva', 'García')
WHERE p. apellido = 'López';
END;
/
Página 132 de 135

Borrado
Para eliminar objetos (filas) de una tabla, utilizaremos el comando DELETE. Si
tenemos que hacer un borrado selectivo, añadiremos la cláusula WHERE. Por
ejemplo:
CÓDIGO
-- Ejemplo
BEGIN
DELETE FROM person p
WHERE p.direccion = 'c/larga, 7';
END;
/
Página 133 de 135

Bibliografía
Alfonso González (2010). Gestión de Bases de Datos. Madrid.

Arturo Mora (2014). Bases de Datos. Diseño y Gestión. Vallehermoso, Madrid.
Iván López, Manuel de Castro, John Ospino (2014). Bases de Datos. Madrid.
Luis Hueso Ibáñez (2012). Bases de datos. Madrid
Página 134 de 135

Mª Jesús Ramos, Alicia Ramos, Sebastián Rubio (2005).Instalación y mantenimiento de

equipos informáticos. Aravaca, Madrid
Página 135 de 135

Bases de Datos B.

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Bases de Datos B.

Cargado por

Copyright:

Formatos disponibles

Módulo 2

8. TUTORIAL DE INSTALACIÓN SGBD ORACLE .................................................................5

8.1. Instalación software JDK ........................................................................................................ 5

8.2. Instalación del servidor Oracle Database Express .................................................................. 10

8.3. Instalación del cliente Oracle: SQL Developer........................................................................ 16

9. CREACIÓN DE BASES DE DATOS .............................................................................. 21

9.1. Creación de bases de datos en Oracle ................................................................................... 21

9.2. Creación de BBDD en MySQL ................................................................................................ 26

10. GESTIÓN DE USUARIOS .............................................................................................. 33

10.1. Administración de usuarios ................................................................................................. 33

10.2. Administración de privilegios .............................................................................................. 48

10.3. Administración de roles ...................................................................................................... 58

10.4. Administración de perfiles .................................................................................................. 59

10.5. Normativa legal vigente sobre la protección de datos ......................................................... 61

11. PROGRAMACIÓN EN BASES DE DATOS (BBDD) ..................................................... 62

11.1. Entornos de desarrollo al entorno de las BBDD ................................................................... 62

11.2. Sintaxis del lenguaje de programación ................................................................................ 64

11.3. Procedimientos y funciones ................................................................................................ 77

11.4. Control de errores .............................................................................................................. 86

11.5. Cursores y transacciones ..................................................................................................... 91

11.6. Disparadores o triggers..................................................................................................... 105

12. USO DE LAS BBDD OBJETO-RELACIONALES ......................................................... 111

12.1. Características .................................................................................................................. 112

12.2. Tipos de datos objeto ....................................................................................................... 115

12.3. Definición de tipos de objeto ............................................................................................ 116

12.4. Herencia ........................................................................................................................... 123

12.5. Identificadores, referencias............................................................................................... 125

12.6. Tipos de datos colección ................................................................................................... 126

12.7. Declaración e inicialización de objetos .............................................................................. 129

12.8. Sentencia SELECT. Inserción, modificación y borrado de objetos........................................ 131

BIBLIOGRAFÍA .................................................................................................................. 134

En el libro anterior de bases de datos A ya estuvimos analizando los primeros pasos

8. Tutorial de instalación SGBD Oracle

Para la instalación del SGBD de Oracle necesitamos instalar primero el software de

8.1. Instalación software JDK

El SGBD de Oracle está desarrollado en Java y se ejecuta sobre la plataforma de

Para instalar JDK en nuestra computadora debemos seguir estos pasos:

2. Navegamos por la web hasta acceder a la sección de descargas JDK.

3. Seleccionamos la descarga para el sistema operativo y arquitectura que nos

4. Aceptamos las condiciones de uso antes de la descarga.

6. Una vez realizado el paso anterior, descargaremos en nuestra computadora el

7. Una vez descargado, comenzaremos con el proceso de instalación.

8. La instalación nos pregunta por la ruta de la carpeta de instalación. Tiene una

9. La instalación avanzará de manera automática.

8.2. Instalación del servidor Oracle Database Express

Una vez ya tenemos instalado el JDK, pasaremos a descargar e instalar el servidor

1. Accedemos a la sección de descarga de Oracle Database Express dentro de la web

2. Elegimos la descarga correspondiente según el sistema operativo de nuestra

3. Tras el paso anterior, un archivo con el software deseado se descargará en modo

4. Una vez descargado el archivo, lo descomprimimos

5. Una vez descomprimido, pasamos a la configuración e instalación del servidor.

7. Llegado el momento, el sistema nos pedirá una contraseña para el servidor. Es

8. A continuación, la instalación se efectuará. Puede tardar unos minutos.

9.Cuando el asistente finalice la instalación, solo quedará seleccionar la opción

8.3. Instalación del cliente Oracle: SQL Developer

Una vez realizada la instalación de la parte del servidor, procederemos a instalar la

Descargar SQL Developer

2. Seleccionamos la descarga adecuada en función de nuestro sistema operativo.

4. Una vez validada nuestra cuenta, se descargará automáticamente el archivo de

Desempaquetar y descomprimir el software

Una vez comprobado que el cliente SQL Developer funciona

9. Creación de bases de datos

9.1. Creación de bases de datos en Oracle

Antes de empezar con la creación de la BD vamos a conectar el software cliente con