Sql-Oracle 10G

ORACLE10G.
Lenguaje SQL
Autor: CLEFormación S.L
Localidad y año de impresión: Madrid, 2010
Copyright: CLEFormación
Oracle Designer, Oracle Reports, PL/SQL, SQL*Plus,Oracle Enterprise Manager son marcas
registradas por Oracle Corporation
Windows, Visual Basic son marcas registradas por Microsoft Corporation.
Índice 1
Capítulo 1. Introducción a SQL
Introducción al lenguaje SQL ........................................................................................1-1

Estándares SQL. SQL: 99 ..............................................................................................1-1
Funcionamiento del lenguaje SQL ................................................................................1-1
Componentes del lenguaje SQL....................................................................................1-2
DDL (Data Definition Languaje - Lenguaje de Definición de Datos) .................................. 1-2
DML (Data Manipulation Languaje - Lenguaje de Manipulación de Datos) ....................... 1-2
Objetos de base de datos ..............................................................................................1-3
Objetos de un esquema ..................................................................................................... 1-3
Objetos no pertenecientes a esquemas ............................................................................. 1-3
Reglas para nombrar objetos de base de datos ................................................................ 1-4
Referenciar objetos de la base de datos ............................................................................ 1-4
Resolución de referencias a objetos .................................................................................. 1-5
Tipos de datos en Oracle10g .........................................................................................1-5
Capítulo 2. Lenguaje de manipulación de datos. DML
Introducción ....................................................................................................................2-1
Sentencia SELECT..........................................................................................................2-1
Selección de todos los datos de una tabla ......................................................................... 2-1
Selección de ciertas columnas de una tabla ...................................................................... 2-2
Cláusula FROM .................................................................................................................. 2-2
Cláusula WHERE ............................................................................................................... 2-3
Cláusula ORDER BY .......................................................................................................... 2-3
Cláusula GROUP BY.......................................................................................................... 2-4
Operadores SQL. ............................................................................................................2-5
Operadores aritméticos ...................................................................................................... 2-5
Operadores concatenación ................................................................................................ 2-5
Operadores de conjuntos ................................................................................................... 2-6
Condiciones SQL. ...........................................................................................................2-8
Condiciones de comparación ............................................................................................. 2-8
Condiciones lógicas............................................................................................................ 2-9
Condiciones de pertenencia. .............................................................................................. 2-9
Condiciones de rango de valores. .................................................................................... 2-10
Condición NULL. .............................................................................................................. 2-10
Condición EXISTS. ........................................................................................................... 2-11
Condición LIKE. ................................................................................................................ 2-11
2 Índice
Funciones. .....................................................................................................................3-12
Funciones Numéricas ....................................................................................................... 2-12
Funciones de cadena de caracteres que devuelven caracteres ...................................... 2-12
Funciones de cadena de caracteres que devuelven números......................................... 2-13
Funciones de fecha y hora ............................................................................................... 2-13
Funciones de conversión.................................................................................................. 2-13
Máscaras de formato. Formatos numéricos ..................................................................... 2-13
Máscaras de formato. Formatos tipo fecha. ..................................................................... 2-14
Otras funciones. ............................................................................................................... 2-16
Variables de entorno. ....................................................................................................... 2-16
Funciones de grupo. La cláusula GROUP BY ................................................................. 2-17
Funciones de grupo. La cláusula HAVING....................................................................... 2-19
Combinaciones de Tablas en versiones anteriores a la 9i .......................................2-20
EQUI JOIN ........................................................................................................................ 2-20
OUTER JOIN .................................................................................................................... 2-21
Uniones de SQL: 1999 ..................................................................................................2-23
Uniones cruzadas ............................................................................................................. 2-23
Uniones naturales ............................................................................................................. 2-23
Uniones de igualdad y la cláusula USING. ...................................................................... 2-24
Predicados de Unión y la Cláusula ON ............................................................................ 2-24
OUTER JOIN. Uniones externas. ..................................................................................... 2-25
La expresión CASE.......................................................................................................2-26
CASE simple..................................................................................................................... 2-26
CASE buscada ................................................................................................................. 2-26
NULLIF ............................................................................................................................. 2-27
COALESCE ...................................................................................................................... 2-27
SUBCONSULTAS ..........................................................................................................2-27
Recuperación jerárquica ..............................................................................................2-30
DML. Lenguaje de manipulación de datos .................................................................2-32
INSERT............................................................................................................................. 2-32
UPDATE ........................................................................................................................... 2-33
DELETE ............................................................................................................................ 2-34
MERGE............................................................................................................................. 2-35
Sentencias Transaccionales........................................................................................2-36
COMMIT ........................................................................................................................... 2-37
SAVEPOINT ..................................................................................................................... 2-37
ROLLBACK....................................................................................................................... 2-38
Índice 3
Capítulo 3. El Lenguaje de definición de datos. DDL
Introducción ....................................................................................................................3-1
Comandos DDL ...............................................................................................................3-1
CREATE TABLE ..............................................................................................................3-1
Sintaxis CREATE TABLE ................................................................................................... 3-1
Integridad de Datos ........................................................................................................3-3
Reglas de Negocio ............................................................................................................. 3-3
Integridad de Entidades...................................................................................................... 3-3
Integridad Referencial ........................................................................................................ 3-4
Nombres de las Restricciones ............................................................................................ 3-5
Cómo Definir Una Restricción ............................................................................................ 3-6
Restricciones: características. ............................................................................................ 3-7
Comprobación de restricciones aplazada .......................................................................... 3-7
Restricciones obligatorias................................................................................................... 3-8
Restricción UNIQUE o PRIMARY KEY utilizando un índice no único. .............................. 3-9
CREATE INDEX .............................................................................................................3-10
Tablas tipo índice ............................................................................................................. 3-10
CREATE SYNONYM ......................................................................................................3-12
CREATE VIEW ...............................................................................................................3-12
CREATE SEQUENCE ....................................................................................................3-13
ALTER TABLE ...............................................................................................................3-14
Añadir Restricciones ......................................................................................................... 3-15
Desactivar Restricciones .................................................................................................. 3-15
Activar Restricciones ........................................................................................................ 3-16
Excepciones Activando Restricciones .............................................................................. 3-16
Borrar Restricciones ......................................................................................................... 3-18
Borrar Columnas .............................................................................................................. 3-18
El Comando ALTER SEQUENCE.................................................................................3-19
DROP TABLE ................................................................................................................3-19
DROP INDEX .................................................................................................................3-19
DROP VIEW ...................................................................................................................3-20
DROP SYNONYM ..........................................................................................................3-20
DROP SEQUENCE ........................................................................................................3-20
RENAME ........................................................................................................................3-20
El Comando TRUNCATE ..............................................................................................3-21
4 Índice
ANEXO A. El interfaz de usuario SQL*PLUS
Introducción ................................................................................................................... A-1

El Editor de SQL*PLUS ................................................................................................. A-2
COMANDOS DE EDICION ............................................................................................... A-2
El Comando SPOOL ......................................................................................................... A-4
El Comando SAVE ............................................................................................................ A-4
El Comando START .......................................................................................................... A-4
El Comando GET .............................................................................................................. A-5
El Comando EDIT .............................................................................................................. A-5
El Comando DESCRIBE ................................................................................................... A-5
El Comando HOST ............................................................................................................ A-5
Parámetros de Sustitución ........................................................................................... A-6
Mejoras en SQL*Plus en Oracle 10g ............................................................................ A-7
Mejoras en el comando DESCRIBE .................................................................................. A-7
Mejoras en el comando SPOOL ........................................................................................ A-7
Configuración de Sesión ................................................................................................... A-7
Nuevas variables DEFINE ................................................................................................. A-8
Variables de Sustitución en PROMPT .............................................................................. A-9
Compatibilidad SQL*Plus .................................................................................................. A-9
ANEXO B. El interfaz de usuario iSQL*PLUS
Utlización de iSQL*Plus ................................................................................................ B-1

Introducción a iSQL*Plus.................................................................................................. B-1
Espacio de Trabajo iSQL*Plus .......................................................................................... B-2
Visualización de Resultados.............................................................................................. B-3
Configuración del Interfaz.................................................................................................. B-4
Configuración de Sistema ................................................................................................. B-5
Cambios en Comandos ..................................................................................................... B-7
Índice 5
ANEXO C. Nuevas Funcionalidades Oracle10g
Introducción ................................................................................................................... C-1

Nuevos Tipos de Datos ................................................................................................. C-1
Operadores de Comparación ............................................................................................ C-3
Nuevas Funciones ............................................................................................................. C-4
Restricciones en Columnas de Coma Flotante ................................................................. C-4
Expresiones Regulares ................................................................................................. C-5
Mecanismo de Búsqueda .................................................................................................. C-5
Meta Caracteres ................................................................................................................ C-6
Funciones .......................................................................................................................... C-7
Expresiones Regulares en DDL ........................................................................................ C-8
Nuevos Métodos de Ordenación .................................................................................. C-9
Parámetros de Configuración ............................................................................................ C-9
Impacto en Sentencias SQL ............................................................................................ C-10
Ejemplo NLS_SORT........................................................................................................ C-10
Función NLSSORT .......................................................................................................... C-11
Cálculos Inter-Filas en SQL ........................................................................................ C-11
Beneficios ........................................................................................................................ C-12
Cláusula SPREADSHEET ............................................................................................... C-12
Terminología .................................................................................................................... C-12
Referencias...................................................................................................................... C-14
Función CURRENTV() .................................................................................................... C-15
Bucles Cualificados Incrementales ................................................................................. C-16
Bucles de Subconsulta Cualificados ............................................................................... C-17
Valores Nulos y No Encontrados..................................................................................... C-17
Opción UPDATE .............................................................................................................. C-19
Orden de Evaluación de Reglas ...................................................................................... C-20
Extensiones a la sentencia MERGE ............................................................................... C-20
Mejoras en CONNECT BY .............................................................................................. C-22
6 Índice
ANEXO D. Funciones
Introducción ................................................................................................................... D-1

Funciones Numéricas ........................................................................................................ D-1
Funciones de cadena de caracteres que devuelven caracteres ....................................... D-4
Funciones de cadena de caracteres que devuelven números.......................................... D-7
Funciones de fecha y hora ................................................................................................ D-8
Funciones de conversión................................................................................................. D-12
Otras funciones. .............................................................................................................. D-16
Ejercicios Lenguaje SQL
Modelo de datos ................................................................................................................1

Ejercicios con la sentencia select.................................................................................... 1
Select ‘simples’ ...................................................................................................................... 1
Subconsultas/joins ................................................................................................................. 2
Ejercicios dml ....................................................................................................................3
Insert ...................................................................................................................................... 3
Update ................................................................................................................................... 3
Delete .................................................................................................................................... 3
Control de transacciones.................................................................................................. 3
Ejercicios ddl e integridad de datos. ............................................................................... 4
Implementación de restricciones de integridad durante la creación de una tabla ................ 4
Implementación de restricciones de integridad después de creación de una tabla.............. 4
Utilización de la tabla de excepciones .................................................................................. 5
Solución a los ejercicios ...................................................................................................6
Select simples........................................................................................................................ 6
Subconsultas / joins ............................................................................................................... 8
Insert .................................................................................................................................... 10
Update ................................................................................................................................. 11
Delete .................................................................................................................................. 11
Implementación de restricciones de integridad durante la creacion de una tabla .............. 11
Utilización de la tabla de excepciones ................................................................................ 12
1
Introducción a SQL
TABLA DE CONTENIDOS
Introducción al lenguaje SQL ........................................................................................... 1

Estándares SQL. SQL: 99 ................................................................................................. 1
Funcionamiento del lenguaje SQL ................................................................................... 1
Componentes del lenguaje SQL....................................................................................... 2
DDL (Data Definition Languaje - Lenguaje de Definición de Datos) ..................................... 2
DML (Data Manipulation Languaje - Lenguaje de Manipulación de Datos) .......................... 2
Objetos de base de datos ................................................................................................. 3
Objetos de un esquema ........................................................................................................ 3
Objetos no pertenecientes a esquemas ................................................................................ 3
Reglas para nombrar objetos de base de datos ................................................................... 4
Referenciar objetos de la base de datos ............................................................................... 4
Resolución de referencias a objetos ..................................................................................... 5
Tipos de datos en Oracle10g ............................................................................................ 5
Introducción a SQL 1-1
INTRODUCCIÓN AL LENGUAJE SQL
SQL (Structured Query Language) es un lenguaje utilizado para el acceso y la

manipulación de los datos almacenados en una base de datos.
El acceso a los datos se realiza mediante aplicaciones o herramientas que utilizan el
lenguaje SQL para mostrar los datos al usuario final.
La historia de SQL (que se pronuncia deletreando en inglés las letras que lo componen,
es decir "ese-cu-ele" y no "siquel" como se oye a menudo) empieza en 1974 con la
definición en los laboratorios de investigación de IBM, de un lenguaje para la
especificación de las características de las bases de datos que adoptaban el modelo
relacional. Este lenguaje se llamaba SEQUEL (Structured English Query Language) y se
implementó en un prototipo llamado SEQUEL-XRM entre 1974 y 1975. Las
experimentaciones con ese prototipo condujeron, entre 1976 y 1977, a una revisión del
lenguaje (SEQUEL/2), que a partir de ese momento cambió de nombre por motivos
legales, convirtiéndose en SQL.
El prototipo (System R), basado en este lenguaje, se adoptó y utilizó internamente en
IBM y lo adoptaron algunos de sus clientes elegidos. Gracias al éxito de este sistema,
que no estaba todavía comercializado, también otras compañías empezaron a desarrollar
sus productos relacionales basados en SQL. A partir de 1981, IBM comenzó a entregar
sus productos relacionales y en 1983 empezó a vender DB2. En el curso de los años
ochenta, numerosas compañías (por ejemplo Oracle y Sybase, sólo por citar algunos)
comercializaron productos basados en SQL, que se convierte en el estándar industrial de
hecho por lo que respecta a las bases de datos relacionales.
ESTÁNDARES SQL. SQL: 99

El lenguaje SQL está sujeto a estándares tanto ANSI como ISO.
Oracle10g cumple con el estándar publicado en Julio de 1999 y llamado SQL:99.
• ANSI X3.135-1999, "Database Language SQL"
• ISO/IEC 9075:1999, "Database Language SQL
FUNCIONAMIENTO DEL LENGUAJE SQL

El lenguaje SQL es un lenguaje de acceso y manipulación de datos, procesa la
información fila a fila y no permite sentencias de control para dirigir el flujo de ejecución.
Existe una extensión al lenguaje SQL, conocida como PL/SQL en el que se incluyen
sentencias de control para poder realizar operaciones con datos obtenidos en sentencias
anteriores.
El SQL permite:
• Almacenar información en tablas.
• Seleccionar la información que sea necesaria de la base de datos.
• Realizar cambios en la información y estructura de los datos.
• Combinar y calcular datos para conseguir la información necesaria.
• Garantizar la integridad y la consistencia de los datos.
1-2 Introducción a SQL
COMPONENTES DEL LENGUAJE SQL

Una base de datos relacional almacena datos en una o más tablas, y estas tablas pueden
ser relacionadas de varias maneras para poder acceder a la información de manera
eficiente. Cumplen las siguientes condiciones:
• Contienen varias tablas.
• Cada tabla es a su vez un conjunto de registros, filas o tuplas.
• Cada registro consta de varias columnas, campos o atributos.
• El nombre de los campos de una tabla es distinto.
• Los valores almacenados en una columna deben ser del mismo tipo de dato.
• Cada registro de la tabla es único.
• Todas las filas de una misma tabla poseen el mismo número de columnas.
• El orden de los registros y de los campos no está determinados.
• Para cada campo existe un conjunto de valores posible.
• La información puede ser recuperada o almacenada por medio de sentencias
llamadas consultas.
Las sentencias SQL pueden ser clasificadas en dos grupos:
DDL (DATA DEFINITION LANGUAJE - LENGUAJE DE DEFINICIÓN DE DATOS)

Las sentencias DDL son aquellas utilizadas para la creación de una base de datos y todos
sus componentes: tablas, índices, relaciones, disparadores (triggers), procedimientos
almacenados, etc. Además permite al usuario otorgar y eliminar privilegios sobre objetos
y sistema de base de datos.
• CREATE  Creación de objetos de base de datos
• ALTER  Modificar los objetos de base de datos ya existentes
• DROP  Eliminar la definición y los datos los objetos de base de datos ya
existentes
• REPLACE  Reemplazar un objeto de base de datos ya existente
• RENAME  Renombrar un objeto de base de datos ya existente
• TRUNCATE  Borrar las filas de una tabla o índice sin eliminar su estructura. El
objeto permanece pero vacío.
• GRANT  Conceder privilegios a usuarios o roles de base de datos.
• REVOKE  Suprimir privilegios a usuarios o roles de base de datos
Las sentencias DDL incorporan COMMIT implícito, no necesitan validación para tener
efecto persistente en la base de datos.
DML (DATA MANIPULATION LANGUAJE - LENGUAJE DE MANIPULACIÓN DE DATOS)

Las sentencias DML son aquellas utilizadas para insertar, borrar, modificar y consultar los
datos de una base de datos.
• SELECT  Consultar datos en la base de datos.
• UPDATE  Actualizar datos en las tablas.
• INSERT  Insertar datos en las tablas.
• DELETE  Borrar datos de las tablas
• MERGE  Inserta y/o actualiza datos en las tablas
Todas las sentencias de manipulación de datos necesitan validación para tener efecto
duradero. COMMIT o ROLLBACK validan o deshacen los cambios realizados en las
tablas.
OBJETOS DE BASE DE DATOS

Los objetos existentes en una base de datos Oracle10g se dividen en dos grandes grupos
dependiendo si están asociados a un esquema (propietario) específico y los objetos que
no están asociados a ningún esquema, es decir, aquellos que son globales a la base de
datos.
OBJETOS DE UN ESQUEMA
Un esquema es una colección de estructuras lógicas de datos. Los esquemas son
propiedad de usuarios de base de datos.
El nombre del esquema de base de datos coincide con el nombre de los usuarios.
Todo esquema de base de datos debe de pertenecer a un usuario, pero pueden existir
usuarios de base de datos que no tengan su propio esquema.
Los objetos son los siguientes:
 Clusters  Restricciones
 Enlaces de base de datos  Disparadores
 Tablas  Vistas
 Sinónimos  Procedimientos almacenados
 Funciones almacenadas
 Paquetes  Secuencias
 Dimensiones  Librerías de procedimientos
 Tablas organizadas como índices  Índices
 Clases Java  Recurso Java
 Fuente Java  Vistas materializadas
 Logs de vistas materializadas  Objetos tabla
 Objetos  Objetos vista
OBJETOS NO PERTENECIENTES A ESQUEMAS

En Oracle10g existen otro tipo de objetos que no pertenecen a un esquema específico de
base de datos.
Son propiedad de la base de datos y se crean, modifican y eliminan mediante sentencias
SQL.
Los objetos son los siguientes:
 Contextos  Directorios
 Fichero de parámetros SPFILE  Perfiles
 Roles  Segmentos UNDO o Rollback
 Tablespaces  Usuarios
REGLAS PARA NOMBRAR OBJETOS DE BASE DE DATOS

Se puede especificar el nombre de un objeto de base de datos Oracle10g de las
siguientes formas:
• El nombre dado a un objeto puede ser entrecomillado (‘’), si cuando se crea un
objeto se ponen comillas, es necesario acceder al objeto utilizando las (‘’)
• El nombre dado a un objeto no es entrecomillado (‘’), el acceso a dicho objeto se
realiza sin comillas. Y el nombre con el que se almacena en las tablas del
diccionario es siempre con mayúsculas.
Independientemente de que nombre dado a un objeto se especifique con comillas o sin
ella las reglas para nombradlos son las siguientes:
• La longitud del nombre del objeto debe de estar comprendida entre 1 carácter y
30. Las excepciones son:
 El nombre de la base de datos como máximo puede tener 8 caracteres.
 Los enlaces de base de datos pueden tener hasta 128 caracteres.
• Si el nombre dado al objeto es entrecomillado puede ser una palabra reservada,
en el caso contrario no puede ser una palabra reservada. No es recomendable
utilizar palabras reservadas para nombrar objetos de base de datos.
• El nombre del objeto debe de comenzar por un carácter alfabético en el caso de
los no entrecomillados.
• Los nombres no entrecomillados pueden empezar por cualquier carácter.
• Los nombres de los objetos deben de ser únicos en el esquema al que pertenecen.
Por ejemplo: dos tablas pueden llamarse igual si pertenecen a distintos esquemas.
• El nombre de las columnas de una tabla debe de ser único en la tabla, pero tablas
distintas pueden tener los mismos nombres de columnas.
REFERENCIAR OBJETOS DE LA BASE DE DATOS

Para acceder a un objeto existente de la base de datos Oracle10g la sintaxis utilizada es
la siguiente:
[esquema.]nombre_objeto[.parte objeto][@enlace base de datos]
Dónde:
•
Esquema  Nombre del esquema que contiene el objeto. Propietario del objeto.
•
Nombre_objeto  nombre del objeto
•
Parte objeto  Parte del objeto. En el caso de un tabla o vista una columna. No
todos los objetos de base de datos tienen partes.
• Enlace de base de datos  nombre del enlace de base de datos en el que reside
el objeto que se quiere referenciar.
Ejemplo:
CONNECT usuario1/contraseña
SELECT * FROM employees;
En este caso el usuario conectado a la base de datos es usuario1, esta accediendo a un

objeto de su propio esquema, en este caso a la tabla employees.
Si este usuario quisiera acceder a un objeto del usuario usuario2, la sintaxis es la
siguiente:
CONNECT usuario1/contraseña
SELECT * FROM usuario2.employees;
Si el acceso se realiza a más de un objeto, es necesario anteponer el nombre del objeto

en las columnas en el caso en el que tuvieran el mismo nombre.
SELECT employees.department_id, departments.department_id

FROM employees, departments;
Además se pueden utilizar alias tanto para el nombre de las tablas referenciadas en la
consulta, como para el nombre de las columnas.
SELECT e. department_id departamento, d. department_id n_departamento

FROM employees e, departments d;
El alias dado a una columna, aparece como encabezado en el resultado de la consulta.
RESOLUCIÓN DE REFERENCIAS A OBJETOS

Cuando se accede a un objeto de base de datos, Oracle10g sigue las siguientes reglas
para acceder al objeto:
• Una tabla perteneciente al usuario conectado.
• Una vista perteneciente al usuario conectado.
• Un sinónimo privado perteneciente al usuario conectado.
• Un sinónimo publico. Estos objetos pertenecen al esquema PUBLIC de la base de
datos.
TIPOS DE DATOS EN ORACLE10G

Las columnas de las tablas de la base de datos tienen una serie de características que se
asocia a un tipo de datos.
Los tipos de datos predefinidos en Oracle10g son los siguientes:
Tipo de dato Descripción

Varchar2(bytes) Cadena de caracteres de longitud variable.
El tamaño esta comprendido entre 1 byte y 4.000 bytes. Se
debe especificar el tamaño.
Nvarchar2(bytes) Cadena de caracteres de longitud variable dependiente del
juego de caracteres nacional indicado en la creación de la base
de datos.
Number(precisión, Número especificando la precisión y los decimales.
decimales) El rango de la precisión es de 1 a 38. El rango para decimales
es de –84 a 127
Long Cadena de caracteres de longitud variable. Tamaño máximo 2
gigabytes.

Date Fecha. El rango esta comprendido entre el 1 de enero de
4.712 antes de Cristo hasta el 31 de diciembre de 9.999
después de Cristo.
El formato depende de las variables NLS
Raw(bytes) Dato binario de longitud variable.
El tamaño máximo es de 2 kilobytes.
Long Raw Cadena binaria de longitud variable.
El tamaño máximo es de 2 gigabytes.
Rowid Cadena en base hexadecimal que representa la dirección única
de una fila dentro de la tabla.
La pseudocolumna rowid devuelve la información en este
formato.
Char(bytes) Cadena de caracteres de longitud fija.
NChar(bytes) Cadena de caracteres de longitud fija dependiente del juego de
caracteres nacional indicado en la creación de la base de
datos.
Clob Tipo de dato objeto grande, que contiene caracteres de byte
simple.
Tamaño máximo 4 gigabytes.
Nclob Tipo de dato objeto grande, que contiene caracteres UNICODE.
Blob Objeto grande de tipo binario.
Bfile Contiene un localizador a un fichero externo de la base de
datos de tipo binario.
TIMESTAMP(precisi Valores de fecha: día, mes y año y de tiempo: horas minutos y
ón) segundos.
La precisión especificada es de 0 a 9 y es el número de dígitos
usados para representar los segundos.
TIMESTAMP(precisi Valores de fecha: día, mes y año y de tiempo: horas minutos y
ón) WITH TIME segundos.
ZONE Utiliza el desplazamiento para la zona horaria.
La precisión especificada es de 0 a 9 y es el número de dígitos
usados para representar los segundos.
TIMESTAMP(precisi Valores de TIMESTAMP WITH TIME ZONE con las excepciones:
ón) WITH LOCAL  Los datos son normalizados al TIME ZONE de la base
TIME ZONE de datos en el momento de almacenarlos
 Al seleccionar este tipo de datos se formatean a la
zona horaria de la sesión que los visualiza
INTERVAL YEAR Almacena un período de tiempo en años y meses.
(precision) TO Precisión  el número de dígitos para el año
MONTH
INTERVAL DAY Almacena un periodo de tiempo en días, minutos y segundos.

(day_precision) TO  day_precision  máximo numero de dígitos para
SECOND almacenar el día
(fractional_seconds_  fractional_seconds_precision  precisión en los
precision) segundos

BINARY_FLOAT Este tipo de datos existe a partir de Oracle 10g, almacenan
datos numéricos de coma flotante en formato IEEE 754 de 32
bits de precisión.
BINARY_DOUBLE Este tipo de datos existe a partir de Oracle 10g, almacenan
datos numéricos de coma flotante en formato IEEE 754 de 64
bits de precisión.
Los tipos de datos RAW y LONG ROW se mantienen por compatibilidad, pero se aconseja
utilizar los tipos LOB de 4 gigabytes.
2
Lenguaje de manipulación de datos.
DML
TABLA DE CONTENIDOS
Introducción .......................................................................................................................1
Sentencia SELECT.............................................................................................................1
Selección de todos los datos de una tabla ............................................................................ 1
Selección de ciertas columnas de una tabla ......................................................................... 2
Cláusula FROM ..................................................................................................................... 2
Cláusula WHERE .................................................................................................................. 3
Cláusula ORDER BY ............................................................................................................. 3
Cláusula GROUP BY............................................................................................................. 4
Operadores SQL. ...............................................................................................................5
Operadores aritméticos ......................................................................................................... 5
Operadores concatenación ................................................................................................... 5
Operadores de conjuntos ...................................................................................................... 6
Operador UNION .............................................................................................................. 6
Operador UNION ALL ...................................................................................................... 6
Operador INTERSECT ..................................................................................................... 6
Operador MINUS .............................................................................................................. 6
Condiciones SQL. ..............................................................................................................8
Condiciones de comparación ................................................................................................ 8
Condiciones lógicas............................................................................................................... 9
Condiciones de pertenencia. ................................................................................................. 9
Condiciones de rango de valores. ....................................................................................... 10
Condición NULL. ................................................................................................................. 10
Condición EXISTS. .............................................................................................................. 11
Condición LIKE. ................................................................................................................... 11
Funciones. ........................................................................................................................12
Funciones Numéricas .......................................................................................................... 12
Funciones de cadena de caracteres que devuelven caracteres ......................................... 12
Funciones de cadena de caracteres que devuelven números............................................ 13
Funciones de fecha y hora .................................................................................................. 13
Funciones de conversión..................................................................................................... 13
Máscaras de formato. Formatos numéricos ........................................................................ 13
Máscaras de formato. Formatos tipo fecha. ........................................................................ 14
Otras funciones. .................................................................................................................. 16
Variables de entorno. .......................................................................................................... 16
Funciones de grupo. La cláusula GROUP BY .................................................................... 17
Funciones de grupo. La cláusula HAVING.......................................................................... 19
Combinaciones de Tablas en versiones anteriores a la 9i .......................................... 20
EQUI JOIN ........................................................................................................................... 20
OUTER JOIN ....................................................................................................................... 21
Uniones de SQL: 1999 .....................................................................................................23
Uniones cruzadas ................................................................................................................ 23
Uniones naturales ................................................................................................................ 23
Uniones de igualdad y la cláusula USING. ......................................................................... 24
Predicados de Unión y la Cláusula ON ............................................................................... 24
OUTER JOIN. Uniones externas. ........................................................................................ 25
LEFT OUTER JOIN: ....................................................................................................... 25
RIGHT OUTER JOIN: .................................................................................................... 25
FULL OUTER JOIN: ....................................................................................................... 25
La expresión CASE..........................................................................................................26
CASE simple........................................................................................................................ 26
CASE buscada .................................................................................................................... 26
NULLIF ................................................................................................................................ 27
COALESCE ......................................................................................................................... 27
SUBCONSULTAS .............................................................................................................27
Recuperación jerárquica ................................................................................................. 30
DML. Lenguaje de manipulación de datos .................................................................... 32
INSERT................................................................................................................................ 32
UPDATE .............................................................................................................................. 33
DELETE ............................................................................................................................... 34
MERGE................................................................................................................................ 35
Sentencias Transaccionales........................................................................................... 36
COMMIT .............................................................................................................................. 37
SAVEPOINT ........................................................................................................................ 37
ROLLBACK.......................................................................................................................... 38
Lenguaje de manipulación de datos. DML 2-1
INTRODUCCIÓN
EL DML (Data Manipulation Lenguage) es un sublenguaje de consulta y manipulación de

datos.
Se entiende por manipulación de datos la:
• Recuperación de Información. Sentencia SELECT.
• Inserción de nueva Información. Sentencia INSERT.
• Eliminación (Borrado) de información existente. Sentencia DELETE.
• Modificación de Información Almacenada. Sentencia UPDATE.
• Inserción y/o modificación de la información nueva o existente. MERGE.
SENTENCIA SELECT.
La recuperación de información (consulta), se realiza mediante la sentencia SELECT.
Básicamente, SELECT se encarga de recoger datos de una o varias tablas. Ahora bien,
podemos estar interesados en todos los datos de unas columnas concretas de las tablas,
en datos que cumplan una cierta condición... para ello, debemos conocer muy bien su
sintaxis que, básicamente, es la siguiente:
SELECT [ALL|DISTINCT] {Lista_Columnas_o_Expresiones | * }

FROM Lista_Tablas
[WHERE Condición_de_búsqueda]
[GROUP BY Lista_Columnas]
[HAVING Condición]
[ORDER BY {expresión|posición}[ASC|DESC];
• Lista_Columnas_o_Expresiones  Enumerar cada una de las columnas a

seleccionar en la recuperación de datos. En el caso de que la consulta acceda a
más de una tabla es necesario anteponer el nombre de la tabla al nombre de la
columna, en el caso de nombre duplicados de columnas.
SELECCIÓN DE TODOS LOS DATOS DE UNA TABLA
Para seleccionar todos los datos de una tabla se utiliza el signo *.

En este caso el orden de aparición de las columnas coincide con el orden seguido a la
hora de crear la tabla.
No es necesario conocer la estructura de las columnas de una tabla para seleccionar
todas las filas y columnas de la misma.
SQL> DESC jobs

Nombre ¿Nulo? Tipo
----------------------------------------- -------- ----------------------
JOB_ID NOT NULL VARCHAR2(10)
JOB_TITLE NOT NULL VARCHAR2(35)
MIN_SALARY NUMBER(6)
MAX_SALARY NUMBER(6)
SQL> SELECT * FROM jobs;
JOB_ID JOB_TITLE MIN_SALARY MAX_SALARY

---------- ----------------------------------- ---------- ----------
AD_PRES President 20000 40000
AD_VP Administration Vice President 15000 30000
2-2 Lenguaje de manipulación de datos. DML
También se pueden especificar todas las columnas en la lista de columnas de la sentencia

SELECT, cada una de ellas se separa de la anterior y posterior mediante comas.
En este caso el orden de aparición de las columnas en el resultado es el orden
especificado en la sentencia SELECT.
Se pueden utilizar ‘alias’ para dar el nombre de la cabecera de la columna en el resultado
de la sentencia SELECT. Los ‘alias’ de las columnas se especifican a continuación del
nombre de la columna y antes de la coma que lo separa de la siguiente columna.
SQL> SELECT job_title Trabajo, job_id Abrev, min_salary salario_minimo,

2 max_salary salario_maximo
3 FROM jobs;
TRABAJO ABREV SALARIO_MINIMO SALARIO_MAXIMO

----------------------------------- ---------- -------------- --------------
President AD_PRES 20000 40000
Administration Vice President AD_VP 15000 30000
SELECCIÓN DE CIERTAS COLUMNAS DE UNA TABLA

Es posible seleccionar algunas columnas de una tabla y no seleccionar la información de
otras columnas.
Solamente se muestra la información de aquellas columnas especificadas en la sentencia
SELECT. El resto de la información de las columnas de la tabla no se muestra al usuario.
SQL> SELECT job_id, job_title

2 FROM jobs;
JOB_ID JOB_TITLE
---------- -----------------------------------
AD_PRES President
AD_VP Administration Vice President
(...)
CLÁUSULA FROM
La información que muestra la sentencia SELECT se extrae de una o varias tablas o
vistas.
Los nombres de la tabla(s) a las que pertenecen las columnas de la sentencia SELECT
deben de aparecer en las tablas especificadas en la cláusula FROM.
El usuario conectado a la base de datos puede consultar datos pertenecientes a tablas de
su propio esquema o a tablas de otros esquemas. En este caso es necesario anteponer el
propietario de la tabla en la cláusula FROM.
SQL> SELECT * FROM usu1.regions;
REGION_ID REGION_NAME
---------- -------------------------
1 Europe
2 Americas
(…)
En el caso en el que los datos obtenidos provengan de varias tablas es conveniente

anteponer el nombre de la tabla antes del nombre de la columna.
SQL> SELECT regions.region_id, regions.region_name, countries.country_name

2 FROM regions, countries
3 WHERE regions.region_id = countries.region_id;
REGION_ID REGION_NAME COUNTRY_NAME

---------- ------------------------- -------------------------------------
1 Europe United Kingdom
1 Europe Netherlands
Se pueden utilizar alias para los nombres de las tablas, de tal manera que se especifica el
nombre del alias en vez del nombre de la tabla en la lista de columnas de la sentencia
SELECT.
SQL> SELECT R.region_id, R.region_name, C.country_name

2 FROM regions R , countries C
3 WHERE regions.region_id = countries.region_id;
REGION_ID REGION_NAME COUNTRY_NAME

---------- ------------------------- -------------------------------------
1 Europe United Kingdom
1 Europe Netherlands
CLÁUSULA WHERE
Es en la cláusula WHERE donde se especifican las condiciones que debe cumplir lo que se
está buscando.
Los predicados utilizados en la condición de búsqueda son los encargados de filtrar los
datos antes de mostrarlos al usuario. Estos predicados pueden ser simples o complejos y
se pueden utilizar operadores y funciones en ellos.
Ejemplo  seleccionar la información de la tabla countries cuyo código sea ‘AR’
SQL> SELECT * FROM countries

2 WHERE country_id = 'AR';
CO COUNTRY_NAME REGION_ID
-- ---------------------------------------- ----------
AR Argentina 2
CLÁUSULA ORDER BY
El resultado de la consulta, por defecto, puede aparecer en cualquier orden.
La cláusula ORDER BY se utiliza para determinar el orden en el que se muestra el
resultado.
Permite ordenar por más de una columna y se admite la ordenación por posición.
La ordenación por defecto es ascendente, pero se puede cambiar utilizando DESC.
El conjunto de caracteres de ordenación está basado en el parámetro NLS_SORT que si
no se especifica toma los valores de NLS_LANGUAGE.
Ejemplo Seleccionar todos los empleados ordenando el resultado por nombre y
salario.
SQL> SELECT * FROM employees

2 ORDER BY last_name,salary;
Ejemplo Seleccionar todos los empleados ordenando el resultado por nombres

ascendentes y salarios descendentes.
SQL> SELECT * FROM employees

2 ORDER BY last_name ASC, salary DESC;
Ejemplo Seleccionar todos los empleados ordenando el resultado por la primera y la

cuarta columna en orden descendente.
SELECT * FROM employees

ORDER BY 1,4 DESC;
Se pueden utilizar expresiones en los criterios de ordenación.

Ejemplo Seleccionar todos los países ordenados por las dos primeras posiciones del
nombre.
SELECT country_name FROM countries

ORDER BY substr(country_name,1,2);
Las restricciones de la cláusula ORDER BY son:

• No se puede utilizar el operador DISTINCT.
• El número máximo de expresiones a ordenar son 255.
• No está permitido ordenar un tipo LOB, varray o tabla anidada.
• En el caso que la sentencia SELECT incluya una cláusula GROUP BY, las
expresiones del ORDER BY están mucho más restringidas.
Las funciones, expresiones y operadores se explican en los siguientes puntos del capítulo.
CLÁUSULA GROUP BY
Los resultados obtenidos de la sentencia SELECT se pueden agrupar y devolver una sola
fila resumen de la información solicitada.
Las expresiones en la cláusula GROUP BY pueden contener cualquier columna
perteneciente a las tablas o vistas especificadas en la cláusula FROM.
Ejemplo  Obtener el salario mínimo y el máximo para el tipo de trabajo ‘ST_MAN’
agrupado por departamento.
SQL> SELECT department_id, MIN(salary), MAX (salary)

2 FROM employees
3 WHERE job_id = 'ST_MAN'
4 GROUP BY department_id;
DEPARTMENT_ID MIN(SALARY) MAX(SALARY)

------------- ----------- -----------
50 5800 8200.
En la cláusula GROUP BY se utilizan funciones de grupo para obtener informes con totales
y subtotales para las columnas.
OPERADORES SQL.
Los operadores SQL se utilizan para manipular los datos de manera individual y devolver
el valor resultante de la operación.
Los operadores o argumentos suelen estar representados por palabras claves o
caracteres especiales (EXISTS, >=).
Genéricamente los operadores se pueden dividir en:
• Unarios  Solamente opera con un operando.
• Binarios  Utilizan dos o más operandos para realizar la operación.
Cuando en una misma expresión aparecen más de un operador, Oracle evalúa los
operadores siguiendo un orden de preferencia de mayor a menor, y en el caso de los
operadores con la misma preferencia los evalúa de izquierda a derecha.
OPERADORES ARITMÉTICOS
Los operadores aritméticos se utilizan para sumar, restar, multiplicar, dividir o negar
valores numéricos.
El resultado de la operación siempre es un número.
UNARIOS
Operador PROPÓSITO Ejemplo
+, - Cambia a positivo o negativo el SELECT * FROM employees

operando sobre el que actúa. WHERE -salary < 0;
BINARIOS
Operador PROPÓSITO Ejemplo
Suman, restan, multiplican, dividen UPDATE employees

+, -,*,/
los operandos. SET salary = salary * 1.4;
OPERADORES CONCATENACIÓN
El operador || concatena cadenas de caracteres y tipos de datos CLOB.
El resultado es una cadena de caracteres.
El tipo de datos resultante depende del tipo de datos de los operandos, pudiendo
combinar tipos de datos CHAR, VARCHAR2 y CLOB en la concatenación.
Ejemplo 
SQL> SELECT 'País: ' || country_name

2 FROM countries;
'PAÍS:'||COUNTRY_NAME
----------------------------------------------
País: Argentina
País: Australia
País: Belgium
País: Brazil
OPERADORES DE CONJUNTOS
Los operadores de conjuntos combinan los resultados de dos consultas con datos
comunes en un único resultado.
Las restricciones de estos operadores son las siguientes:
• Los operadores de conjuntos no pueden operar con columnas de tipo BLOB,
CLOB, BFILE, VARRAY, o tablas anidadas.
• Los operadores UNION, INTERSECT y MINUS no son válidos con columnas LONG.
• Si la lista de columnas que preceden al operador de columnas contiene alguna
expresión, hay que calificarla con un alias.
• No está permitido la cláusula FOR UPDATE.
• No se puede utilizar la cláusula ORDER BY en la subconsulta de los operadores de
conjuntos.
OPERADOR UNION
Devuelve todas las filas distintas seleccionadas por ambas consultas.
OPERADOR UNION ALL

Devuelve todas las filas seleccionadas por ambas consultas incluyendo duplicados.
OPERADOR INTERSECT
Devuelve todas las filas comunes a ambas consultas eliminando los duplicados.
OPERADOR MINUS
Devuelve todas las filas seleccionadas por la primera consulta que no estén recuperadas
en la primera consulta.
Ejemplos:
SQL> SELECT * FROM regions;

---------- -------------------------
1 Europe
2 Americas
3 Asia
4 Middle East and Africa
SQL> SELECT * FROM regiones;

---------- -------------------------
1 Europe
2 Americas
3 Asia
5 Australia
6 Antartida
SQL> SELECT * FROM regions UNION SELECT * FROM regiones;

---------- -------------------------
1 Europe
2 Americas
3 Asia
5 Australia
6 Antartida
SQL> SELECT * FROM regions UNION ALL SELECT * FROM regiones;

---------- -------------------------
1 Europe
2 Americas
3 Asia
1 Europe
2 Americas
3 Asia
5 Australia
6 Antartida
SQL> SELECT * FROM regions INTERSECT SELECT * FROM regiones;

---------- -------------------------
1 Europe
2 Americas
3 Asia
SQL> SELECT * FROM regiones MINUS SELECT * FROM regionS;

---------- -------------------------
5 Australia
6 Antartida
CONDICIONES SQL.
Las condiciones son combinaciones de operadores lógicos y expresiones que devuelven
un resultado. El resultado puede ser VERDADERO, FALSO o DESCONOCIDO.
CONDICIONES DE COMPARACIÓN
Condiciones de comparación
Condición PROPÓSITO Ejemplo
SELECT *
= Comprueba la igualdad FROM employees
WHERE salary = 2500;
!= SELECT *
<> No igualdad, distinto FROM employees
^= WHERE salary != 2500;
SELECT *
> Mayor que FROM employees
WHERE salary > 2500;
SELECT *
< Menor que FROM employees
WHERE salary < 2500;
SELECT *
>= Mayor o igual que FROM employees
WHERE salary >= 2500;
<= Menor o igual que WHERE salary <= 2500;
Compara los valores de la lista devuelta.
Debe de ir precedido de =,!=,<,>,>=,<=. SELECT * FROM employees
El resultado es verdadero si la comparación WHERE salary = ANY
ANY es verdadera para alguno de los valores (SELECT salary
SOME devueltos por la SELECT subordinada, y FROM employees
WHERE department_id =
falso si la SELECT devuelve una tabla vacía,
60);
o si la comparación devuelve falso en todos
los valores de la SELECT subordinada.
Compara los valores de la lista devuelta.
Debe de ir precedido de =,!=,<,>,>=,<=.
El resultado es verdadero si la comparación
es verdadera para todos los valores SELECT * FROM employees
devueltos por la SELECT subordinada, falso WHERE salary >=
ALL ALL ( 2500, 3000);
si para algún valor no nulo se obtiene falso
en la comparación (también puede serlo si
algún valor es nulo), y desconocido si para
todo valor no nulo devuelve cierto la
comparación.
CONDICIONES LÓGICAS
Las condiciones lógicas combinan el resultado de dos componentes de una condición para
obtener un solo resultado.
Son utilizadas para agrupar condiciones
Devolver verdadero en el caso de que SELECT *
NOT la condición sea falsa. FROM employees
Verdadero en el caso contrario. WHERE NOT (job_id IS NULL);
SELECT *
Devolver verdadero si los dos
FROM employees
componentes de la condición son WHERE job_id = 'PU_CLERK'
AND
verdaderos. AND department_id = 50;
Falso en caso contrario
Devolver verdadero si uno de los SELECT *
componentes de la condición es FROM employees
OR verdadero. WHERE job_id = 'PU_CLERK'
OR department_id = 50;
Falso en caso de que ambos
componentes sean falsos.
CONDICIONES DE PERTENENCIA.
Las condiciones de pertenencia evalúan si los operandos de la parte izquierda de la
comparación pertenecen o no a la lista de valores o subconsulta situada en la parte
derecha.
CONDICIONES DE PERTENENCIA
Averiguar si el resultado de la evaluación de
WHERE salary IN( 2500,
una expresión está incluido en la lista de 3000, 2000;
valores especificado tras la cláusula IN.
Si expresión no es nulo y pertenece a la lista SELECT * FROM employees
IN WHERE salary IN
de valores (o el SELECT), obtendremos
(SELECT salary
verdadero, si no pertenece falso, y si es nulo,
FROM employees
desconocido. WHERE department_id =
Equivalente al operador de comparación ANY 60);
Averiguar si el resultado de la evaluación de SELECT * FROM employees
WHERE salary NOT IN (
una expresión no está incluido en la lista de 2500, 3000, 2000);
valores especificado tras la cláusula NOT IN.
NOT IN Si expresión no es nulo y no pertenece a la SELECT * FROM employees
lista de valores (o el SELECT), obtendremos WHERE salary NOT IN
(SELECT salary
verdadero, si pertenece falso, y si es nulo,
FROM employees
desconocido. WHERE department_id =
Equivalente al operador de comparación !=ALL. 60);
CONDICIONES DE RANGO DE VALORES.

Las condiciones de rango de valores evalúan si los operandos de la parte izquierda de la
comparación pertenecen o no al rango de valores especificado en la parte derecha de la
condición.
Condiciones de rango de valores

BETWEEN x Averiguar si el resultado de la WHERE salary
condición es mayor o igual que x y
AND y BETWEEN 2000 AND 3000;
menor o igual que y.

NOT
Averiguar si el resultado de la WHERE salary NOT
BETWEEN x condición no es mayor o igual que x
BETWEEN 2000 AND 3000;
y menor o igual que y.
AND y
CONDICIÓN NULL.
La condición NULL evalúa si el operando de la parte izquierda es un valor nulo.
Condición NULL
Evaluar si el operando es el valor NULL. SELECT *

El resultado será verdadero en caso de que la FROM employees
IS NULL columna tenga el valor NULL (NO es lo WHERE salary IS NULL;
mismo que 0 o cadena vacía) y falso si no es
así.
Evaluar si el operando no es el valor NULL. SELECT *

FROM employees
El resultado será verdadero en caso de que la
IS NOT NULL columna no tenga el valor NULL (NO es lo WHERE salary IS NOT
mismo que 0 o cadena vacía) y falso si no es NULL;
así.
CONDICIÓN EXISTS.
La condición EXISTS evalúa si el operando existe en el las filas retornadas por la
subconsulta de la parte derecha.
Condición EXITS

SELECT salary
Devuelve verdadero si el resultado del
FROM employees e
subselect es una tabla con una o más filas, y WHERE EXISTS
EXISTS falso si el resultado del subselect es una (SELECT *
tabla vacía. FROM departments d
WHERE d.department_id
= e.department_id);
CONDICIÓN LIKE.
Con la condición LIKE se establece un patrón de búsqueda para el caso de las columnas
con valores que sean de tipo carácter.
Hay dos caracteres que son especiales, '_' y '%'.
El primero tiene el significado de ser sustituido por un carácter cualquiera, y el segundo
por una subcadena completa.
Condición LIKE
Devuelve verdadero si el resultado de la SELECT salary

comparación de las cadenas de caracteres FROM employees
X LIKE Y WHERE last_name LIKE
coincide con el patrón de búsqueda
especificado. 'R%';
Devuelve verdadero si el resultado de la SELECT salary

X NOT comparación de las cadenas de caracteres no FROM employees
LIKE Y coincide con el patrón de búsqueda WHERE last_name NOT
LIKE 'R_';
especificado.
FUNCIONES.
Una función SQL es similar a un operador ya que manipula los datos de entrada y
devuelve un valor.
Las funciones SQL convierten el tipo de dato que reciben como argumento si ese es
distinto al que tiene definido como argumento de entrada.
Las funciones SQL se pueden dividir en dos grandes grupos:
• Funciones de fila simple  Son las funciones que devuelven un resultado único
para cada una de las filas sobre las que actúan.
• Funciones de grupo  Devuelven un resultado único para un conjunto de filas de
entrada.
En el Anexo D se incluye un gran número de funciones SQL, clasificadas según su
pertenencia a los grupos que a continuación se relacionan.
FUNCIONES NUMÉRICAS
Son funciones de fila simple, aceptan como argumentos de entrada valores numéricos y
devuelven un resultado numérico.
Ejemplo:
SQL> SELECT ABS(-25) FROM DUAL;

ABS(-25)
----------
25
FUNCIONES DE CADENA DE CARACTERES QUE DEVUELVEN CARACTERES

Este tipo de funciones reciben como argumento una cadena de caracteres y una vez
aplicada la función devuelven una cadena de caracteres.
Son funciones de fila simple.
Las restricciones son las siguientes:
• Las funciones que devuelven una cadena de caracteres tipo CHAR están limitadas
a 2.000 caracteres. En el caso de que el valor de retorno supere los 2.000
caracteres se trunca el resultado a 2.000 y no se genera error.
• Las funciones que devuelven una cadena de caracteres tipo VARCHAR2 están
limitadas a 4.000 caracteres. En el caso de que el valor de retorno supere los
4.000 caracteres se trunca el resultado a 4.000 y no se genera error.
• Las funciones que devuelven una cadena de caracteres tipo CLOB están limitadas
a 4 GB. En el caso de que el valor de retorno supere los 4 GB se genera un error
y no se devuelven datos.
Ejemplo:
SQL> SELECT initcap('el nombre') FROM DUAL;

INITCAP('
---------
El Nombre
FUNCIONES DE CADENA DE CARACTERES QUE DEVUELVEN NÚMEROS

Son funciones de fila simple que retornan un valor numérico, tendiendo como argumento
de entrada una cadena de caracteres.
Ejemplo:
SQL> SELECT LENGTH('hola mundo') FROM DUAL;
LENGTH('HOLAMUNDO')
-------------------
10
FUNCIONES DE FECHA Y HORA

Las funciones de fecha y hora realizan operaciones sobre tipos de datos DATE y
devuelven un valor de tipo DATE o INTERVAL.
Ejemplo:
SQL> SELECT NEXT_DAY(sysdate,'DOMINGO') FROM DUAL;

NEXT_DAY(SYSDATE,'DO
--------------------
16-MAR-2003 11:20:41
FUNCIONES DE CONVERSIÓN
Este tipo de funciones convierten un tipo de datos en otro. El primer tipo de datos se
convierte en el segundo.
Ejemplo:
SQL> SELECT TO_CHAR(SYSDATE, 'Month DD, YYYY') "Hoy" FROM DUAL;
Hoy
-------------------
Diciembre 11, 2008
MÁSCARAS DE FORMATO. FORMATOS NUMÉRICOS

• Deben proporcionarse las máscaras de conversión en formato numérico
adecuadas cuando:
 En una función TO_CHAR se cambie un tipo de dato NUMBER a un tipo de dato
VARCHAR2
 En una función TO_NUMBER se cambie un tipo de dato CHAR o VARCHAR2 a
NUMBER.
• Los formatos numéricos están compuestos de uno o elementos de formatos:
Elemento Ejemplo Descripción

9 9999 El número de "9" especifica la cantidad de dígitos que se visualizan. Se
visualizan blancos para los ceros a la izquierda.
0 0999 Visualiza los ceros a la izquierda en esa posición
9990 Como ceros en vez de como blancos, o les da valor de 0 en lugar de
blanco.
$ $9999 Antepone como prefijo el signo de dólar.
B B9999 Devuelve los ceros como blancos, a menos que se indique "0" en la
máscara de formato
MI 9999MI Muestra un "-" después de los valores negativos. Para los valores
positivos muestra un espacio en blanco.
S S9999 Muestra un "+" para los valores positivos y "-" para los negativos en la
posición indicada.
PR 9999PR Muestra los valores negativos entre los signos de menor y mayor <>.
D(*) 99D99 Muestra el carácter decimal en la posición indicada. Separa la parte
entera y fraccionaria de un número.
G(*) 9G999 Muestra el separador de grupo en la posición indicada.
C(*) C9999 Muestra el símbolo ISO de la moneda, en la posición indicada.
L(*) L999 Muestra el símbolo de la moneda local en la posición indicada.
,(coma) 9,999 Muestra una coma en la posición indicada.
.(punto) 99.99 Muestra un punto en la posición indicada y separa la parte entera y la
decimal de un número.
EEEE 9.999EEEE Muestra el valor en notación científica.
RN RN Devuelve en mayúsculas o minúsculas (rn) el valor del número en
romano. El número tiene que ser un entero entre 1 y 3999
• MI y PR solo pueden estar en la última posición de un formato numérico. Y el
formato S sólo en la primera o la última posición.
(*) Los caracteres que devuelven los formatos indicados con un asterisco son
especificados por los siguientes parámetros de inicialización de la Base de Datos.
D Carácter Decimal NLS_NUMERIC_CHARACTERS

G Separador Grupo NLS_NUMERIC_CHARACTERS
C Símbolo moneda ISO NLS_ISO_CURRENCY
L Símbolo moneda NLS_CURRENCY
MÁSCARAS DE FORMATO. FORMATOS TIPO FECHA.

Los formatos de fecha se utilizan en las siguientes situaciones:
• En la función TO_CHAR para convertir un valor tipo DATE a un formato diferente
al formato por defecto.
• En la función TO_DATE para convertir un valor tipo carácter en un formato
diferente que el de por defecto.
La fecha por defecto se especifica de manera explícita con el parámetro
NLS_DATE_FORMAT o implícitamente con el parámetro de inicialización
NLS_TERRITORY. Se puede sobrescribir el valor de estos parámetros para la sesión
actual con el comando ALTER SESSION.
Elemento Significado
────────────────────────────────────────────────────────────────
SCC ó CC Indica el siglo. Si se indica S en las fechas de antes de Xto.
Aparece el prefijo "-".
YYYY ó SYYYY Visualiza los 4 dígitos del año. S antepone un guión "-" si la
fecha es antes de Xto.
IYYY Los 4 dígitos del año en formato ISO estándar.
YYY ó YY ó Y Los últimos 3, 2 o 1 dígitos del año.
IYY ó IY ó I Los últimos 3, 2 o 1 dígito del año en formato ISO estándar.
Y,YYY El año con una coma en la posición indicada.
SYEAR ó YEAR El número de año nombrado. El prefijo S antepone un guión

si es antes de Xto.
RR Los últimos dos dígitos del año. Se utiliza para años de otros
siglos.
BC ó AD Indicador antes/después de Xto.
B.C. ó A.D. Indicador antes/después de Xto. Separado por puntos.
Q Trimestre del año. P.e. de Enero a Marzo = 1.
MM Número de Mes. P.e. Enero=1
RM Número de Mes en romano. P.e. Julio=VII
MONTH Nombre del mes en letra, alineado con blancos de hasta 9
caracteres de longitud.
MON Nombre del día abreviado a tres letras.
WW Número de la semana del año.
IW Número de la semana del año en ISO estándar.
W Semana del mes.
DDD Número de día del año. (1-366).
DD Número de día del mes. (1-31).
D Número de día de la semana. (1-7)
DAY Nombre del día de la semana hasta 9 caracteres.
DY Nombre del día de la semana abreviado.
J Fecha en Juliano. Los números especificados deben ser
enteros.
AM ó PM Indicador de Meridiano.
A.M. ó P.M. Indicador de Meridiano separado por puntos.
HH ó HH12 Hora del día (1-12)
HH24 Hora del día (0-23)
MI Minutos (0-59).
SS Segundos (0-59)
SSSSS Segundos transcurridos desde medianoche.
(0-86399).
• Las especificaciones de algunos formatos, (Month, Mon, day, Dy, BC/AD,

B.C./A.D., AM/PM) dependen del lenguaje utilizado en la B.D. indicados en los
parámetros de inicialización:
 NLS_DATE_LENGUAGE
 NLS_TERRITORY
 NLS_LANGUAGE
• Las máscaras de formato YEAR y SYEAR devuelven el nombre del año SIEMPRE
en inglés.
OTRAS FUNCIONES.
Hay multitud de funciones no encuadradas en ninguno de los grupos de funciones
relacionados anteriormente que aportan gran potencia y funcionalidad a las sentencias
SQL. Algunas de ellas son imprescindibles como NVL o aportan gran potencia como
DECODE o permiten el manejo de tipos de datos LOB como EMPTY_[B|C]LOB o
BFILENAME.
También existen funciones de usuario desarrolladas en PL/SQL y almacenadas en el
Servidor de B.D. Se utilizan cuando la funcionalidad que deseamos no está disponible en
SQL y sus funciones. Para crearlas se utiliza CREATE FUNCTION o pueden residir dentro
de un paquete creado con CREATE PACKAGE.
VARIABLES DE ENTORNO.
UID Sintaxis UID
Propósito Devuelve un entero que es el identificador único de el usuario
conectado.
Ejemplo
SELECT UID FROM DUAL
USER
Sintaxis USER
Propósito Devuelve un VARCHAR2 que contiene el nombre del usuario
conectado en la base de datos local.
Ejemplo
SELECT USER, UID FROM DUAL

USER UID
---------- ------
USU1 9
USERENV
Sintaxis USERENV (opción)
Propósito Devuelve información en un tipo de dato VARCHAR2 acerca de la
sesión actual. El argumento opción puede tener los valores:
'ENTRYID'. Devuelve un identificador de la sentencia ejecutada para
auditorías.
'LANGUAGE'. Devuelve el lenguaje y el territorio utilizado durante la
sesión en formato:
lenguaje_territorio_juegocaracteres
'SESSIONID'. Devuelve un identificativo de la sesión del usuario para
auditorías.
'TERMINAL'. Devuelve el identificativo del sistema operativo para el
terminal utilizado.
Ejemplo
SELECT USERENV('LANGUAGE') "Idioma" FROM DUAL

Idioma
-------------------------
AMERICAN_AMERICA.US7ASCII
FUNCIONES DE GRUPO. LA CLÁUSULA GROUP BY

• Las funciones de grupo devuelven un resultado basado en un grupo de filas, más
que sobre una fila solamente.
• Algunas funciones de grupo aceptan las siguientes opciones:
 DISTINCT: Esta opción provoca que la función de grupo considere solamente
los distintos valores de la expresión. También puede utilizarse sin funciones de
grupo.
Ejemplo:
SQL> SELECT distinct(job_id) FROM employees;
JOB_ID
----------
CLERK
SALESMAN
MANAGER
ANALYST
PRESIDENT
 ALL: Esta opción provoca que la función de grupo considere todos los valores
recuperados, incluyendo duplicados. Es la opción por defecto.
• Todas las funciones de grupos excepto COUNT(*) ignoran los valores nulos.
• A continuación se muestran algunas de las funciones de grupo más utilizadas:
AVG Sintaxis AVG([DISTINCT|ALL] n)

Propósito Devuelve la media de n.
Ejemplo
SELECT AVG(salary) "Media" FROM employees;

Media
----------
2073.21429
COUNT Sintaxis COUNT({* | DISTINCT|ALL] expr})

Propósito Devuelve el numero de filas en la consulta.
Ejemplo
SELECT COUNT(*) "Total" FROM employees;

Total
-----
14
SELECT COUNT(job_id) "Contar" FROM employees;

Contar
------
14
SELECT COUNT(DISTINCT job_id)"Trabajos" FROM employees;

Trabajos
--------
4
MAX Sintaxis MAX([DISTINCT|ALL] expr)

Propósito Devuelve el valor máximo de la expresión.
Ejemplo
SELECT MAX(salary) "Máximo" FROM EMPLOYEES;

Máximo
----------
5000
MIN Sintaxis MIN([DISTINCT|ALL] expr)

Propósito Devuelve el valor mínimo de la expresión.
Ejemplo
SELECT MIN(salary) "Mínimo" FROM EMPLOYEES;

Mínimo
----------
800
STDDEV Sintaxis STDDEV([DISTINCT|ALL] x)

Propósito Devuelve desviación estándar de x.
Ejemplo
SELECT STTDEV(salary) "Desviación" FROM employees;

Desviación
----------
1182.50322
SUM Sintaxis SUM([DISTINCT|ALL] n)

Propósito Devuelve la suma de los valores de n.
Ejemplo
SELECT SUM(salary) "Suma" FROM employees;

Suma
----------
29025
VARIANCE
Sintaxis VARIANCE([DISTINCT|ALL] x)
Propósito Devuelve la varianza de x. Un número.
Ejemplo
SELECT VARIANCE(salary) "Variación" FROM employees;

Variación
----------
1389313.87
• Se puede utilizar la cláusula GROUP BY para agrupar las filas seleccionadas y

devolver una sola fila resumiendo la información solicitada. La selección de los
conjuntos de filas se realizan para calcular propiedades de los conjuntos,
basándose en los valores de la expresión(es) especificados en la cláusula GROUP
BY.
• Si la sentencia SELECT contiene la cláusula GROUP BY, la lista de la SELECT solo
puede contener los siguientes tipos de expresiones:
 Constantes
 Funciones de Grupo
 Expresiones idénticas a las que estarán en la cláusula GROUP BY.
 Expresiones implícitas en las expresiones mencionadas en la SELECT que
evalúen el mismo valor para todas las filas de un grupo.
• Las expresiones en la cláusula GROUP BY pueden contener cualquier columna de
una tabla o vista mencionada en el FROM, sin importar que estas columnas estén
o no en la lista de la SELECT.
• En el siguiente ejemplo muestra el máximo y el mínimo de los salarios para cada
departamento.
• En el ejemplo a continuación veremos como recuperar el mínimo y el máximo de
los salarios de las personas cuyo trabajo sea 'CLERK' (empleado) dentro de cada
departamento.
SQL> SELECT department_id deptno, MAX(salary), MIN(salary)

2 FROM employees
DEPTNO MAX(SALARY) MIN(SALARY)

---------- ----------- -----------
100 12000 6900
30 11000 2500
7000 7000
90 24000 17000
20 13000 6000
SQL> SELECT department_id deptno, MAX(salary), MIN(salary)

2 FROM employees
3 WHERE job_id LIKE '%CLERK'
DEPTNO MAX(SALARY) MIN(SALARY)

---------- ----------- -----------
30 4464 3600
50 6048 3024
FUNCIONES DE GRUPO. LA CLÁUSULA HAVING

• Se puede utilizar la cláusula HAVING para restringir el número de grupos de filas
definidas en la GROUP BY que se visualizan. El procesamiento de la sentencia es
el siguiente:
 Si la sentencia contiene una cláusula WHERE, primero se filtran todas las filas
que no satisfagan la condición.
 Se realizan los cálculos especificados y se forman los conjuntos de filas
especificados en GROUP BY.
 Solo se muestran los subconjuntos recuperados que satisfacen la cláusula
HAVING
Por ejemplo, visualizar el máximo y el mínimo de los salario de employees cuyo trabajo
sea el de empleado ('CLERK') para cada departamento y que además su salario mínimo
esté por debajo de $3500.
SQL> SELECT department_id, MAX(salary), MIN(salary)

2 FROM employees
3 WHERE job_id LIKE '%CLERK'
4 GROUP BY department_id
5 HAVING MIN(salary)<3500;
DEPARTMENT_ID MAX(SALARY) MIN(SALARY)

------------- ----------- -----------
50 6048 3024
COMBINACIONES DE TABLAS EN VERSIONES ANTERIORES A LA 9I
EQUI JOIN
• Un "join" es una sentencia SELECT que combina filas de dos o más tablas o
vistas. Cada fila mostrada contiene datos de 2 o más tablas. La cláusula WHERE
es la que determina como se realiza la combinación.
• Si la cláusula WHERE es inexistente o inadecuada puede realizarse un producto
cartesiano, que combinará todas las filas de todas las tablas implicadas en la
combinación.
• El producto cartesiano genera un número de filas muy elevado. Por ejemplo, si
combino dos tablas con 100 filas cada una, sin establecer cláusula where, se
generarán 10.000 filas. Por lo tanto, siempre debe incluirse un criterio de
combinación.
• El tipo de combinación más utilizado es el llamado "simple join" o "equi join", que
devuelve filas de dos o más tablas basándose en una condición de igualdad. El
criterio de combinación por lo tanto lo establece el operador "="
• Suponiendo que unimos dos tablas, la sintaxis básica sería la siguiente:
SELECT Columnas de las tablas citadas en la cláusula FROM. Si existen columnas con
el mismo nombre en ambas tablas, es conveniente anteponer
nombre_tabla.nombre_columna o bien, alias_tabla.nombre_columna.
FROM Tablas de las que se extrae información. Por ejemplo: tabla1 alias1, tabla2
alias2
WHERE Criterio de combinación de las tablas.

Por ejemplo: tabla1.columna = tabla2.columna, o bien,
alias1.columna = alias2.columna
• Se pueden seleccionar TODAS las columnas de ambas tablas. NO es necesario
que las columnas mencionadas en el criterio de combinación sean seleccionadas.
Ejemplo
En ejemplo siguiente muestra cómo recuperar el nombre y el número de departamento
en el que trabaja cada empleado.
SELECT e.first_name,e.department_id,d.department_name
FROM employees e, departments d
WHERE e.department_id = d.department_id;
FIRST_NAME DEPARTMENT_ID DEPARTMENT_NAME

Steven 90 Executive
Neena 90 Executive
Lex 90 Executive
Alexander 60 IT
Bruce 60 IT
David 60 IT
Valli 60 IT
Diana 60 IT
Nancy 100 Finance
Daniel 100 Finance
.
.
.
OUTER JOIN
El outer join o combinación externa amplifica el resultado de una combinación simple.
Una combinación externa recupera TODAS las filas de la de la combinación externa y
también aquellas que no encuentren su correspondiente fila pareja de una tabla a otra.
Ejemplo:
Seleccionar el número de departamento, el nombre de departamento y el salario
mensual para cada departamento sin utilizar combinación externa:
SELECT d.department_id, d.department_name, SUM(salary) "Salario Mensual"

WHERE e.department_id = d.department_id
GROUP BY d.department_id, d.department_name
ORDER BY d.department_id;
DEPARTMENT_ID DEPARTMENT_NAME Salario Mensual

10 Administration 4400
20 Marketing 19000
30 Purchasing 24900
40 Human Resources 6500
50 Shipping 156400
60 IT 28800
70 Public Relations 10000
80 Sales 304500
90 Executive 58000
100 Finance 51600
110 Accounting 20300
11 filas seleccionadas.
• Para seleccionar el total de salarios mensuales para todos los departamentos

independientemente de que tengan empleados o no, tendremos que utilizar un
OUTER JOIN.
SELECT d.department_id, d.department_name, SUM(salary) "Salario Mensual"
WHERE e.department_id(+) = d.department_id
GROUP BY d.department_id, department_name
ORDER BY d.department_id;
DEPARTMENT_ID DEPARTMENT_NAME Salario Mensual

10 Administration 4400
20 Marketing 19000
30 Purchasing 24900
40 Human Resources 6500
50 Shipping 156400
60 IT 28800
70 Public Relations 10000
80 Sales 304500
90 Executive 58000
100 Finance 51600
110 Accounting 20300
120 Treasury
130 Corporate Tax
140 Control And Credit
150 Shareholder Services
160 Benefits
170 Manufacturing
180 Construction
190 Contracting
200 Operations
210 IT Support
220 NOC
230 IT Helpdesk
240 Government Sales
250 Retail Sales
260 Recruiting
270 Payroll
27 filas seleccionadas.
Sintaxis:
SELECT col1, col2, .... coln
FROM tabla1, tabla2, ...
WHERE tabla1.col1 = tabla2.col1(+)
El símbolo (+) debe situarse en el predicado de combinación al lado de la columna o
columnas pertenecientes a la tabla en la que hay ausencia de valor. En el ejemplo el
departamento 40 (OPERATIONS) existe, pero no tiene empleados.
UNIONES DE SQL: 1999

A partir de Oracle 9i, se ha implementado la sintaxis completa de uniones de SQL: 1999.
La unión se especifica en la cláusula FROM. La nueva sintaxis es más fácil de leer y
menos propensa a errores ya que permite separar los predicados de unión de los otros
predicados. También es más potente en las uniones externas, ya que soporta uniones
externas completas.
Tipos de uniones:
• Uniones cruzadas.
• Uniones naturales.
• Uniones de igualdad y la cláusula USING.
• Uniones externas (completa, izquierda y derecha).
UNIONES CRUZADAS
Son equivalentes al producto cartesiano de dos tablas. La sintaxis a utilizar es CROSS
JOIN.
SELECT e.last_name, d.department_name

FROM employees e CROSS JOIN Departments d;
El ejemplo anterior es equivalente a:
SELECT last_name, department_name

FROM employees, departments;
UNIONES NATURALES
La unión natural es una unión de igualdad basada en todas las columnas que tienen el
mismo nombre. Los tipos de datos que contienen deben ser compatibles. No es posible
utilizar un prefijo de alias para una columna de unión.
La sintaxis a utilizar es NATURAL JOIN.
Si se recuperan todas las columnas mediante la sintaxis SELECT *, las columnas
comunes aparecerán una sola vez en los resultados. Por tanto, no es necesario utilizar
alias de tabla para cualificar las columnas en las consultas de unión natural, de hecho, si
se emplea dará un error.
SELECT employee_id, last_name, department_id

FROM employees NATURAL JOIN departments;
Esta sentencia sería equivalente a la siguiente:
SELECT employee_id, last_name, d.department_id

WHERE e.department_id = d.department_id AND
e.manager_id=d.manager_id;
UNIONES DE IGUALDAD Y LA CLÁUSULA USING.

En las uniones naturales se usan todas las columnas con nombres comunes para llevar a
cabo la unión de las tablas. Si dos tablas tienen más de un nombre de columna en
común, pero se desea especificar sólo una de ellas para llevar a cabo la unión, se
empleará la cláusula USING.
• No se puede utilizar alias de tabla en las columnas a las que hace referencia la
cláusula USING.
• Las cláusulas NATURAL y USING son mutuamente excluyentes.
• En las uniones naturales y en las uniones de igualdad no es posible utilizar
columnas tipo LOB como columnas de unión.
SELECT employee_id, last_name, job_history.department_id
FROM employees
JOIN job_history
USING (employee_id);
La sentencia anterior es equivalente a la siguiente:

SELECT employees.employee_id, last_name, job_history.department_id
FROM employees, job_history
WHERE employees.employee_id=job_history.employee_id;
PREDICADOS DE UNIÓN Y LA CLÁUSULA ON

La cláusula ON permite separar los predicados de unión de los que no lo son; esta
separación permite clarificar el código de las sentencias SQL y por tanto disminuir la
posibilidad de cometer errores.
La cláusula ON permite el uso de cualquier predicado, incluyendo las subconsultas y los
operadores lógicos.
SELECT employees.employee_id, last_name, job_history.department_id
FROM employees
JOIN job_history
ON (employees.employee_id=job_history.employee_id)
WHERE manager_id=100;
SELECT e.last_name employee, m.last_name manager
FROM employees e
JOIN employees m
ON (e.manager_id=m.employee_id);
• Mediante la cláusula ON es posible realizar uniones en Tres Sentidos, es decir una

unión de tres tablas. En SQL: 1999 las uniones se llevan a cabo de izquierda a
derecha. En el siguiente ejemplo la primera unión que se realiza es la de las
tablas EMPLOYEES y DEPARTMENTS pero sin referenciar las columnas de la tabla
LOCATIONS. La segunda condición de unión referencia las columnas de las tres
tablas.
SELECT employee_id, city, department_name
FROM employees e
JOIN departments d
ON d.department_id = e.department_id
JOIN locations l
ON d.location_id = l.location_id;
La anterior sentencia sería equivalente a la siguiente:
SELECT employee_id, city, department_name

FROM employees, departments, locations
WHERE employees.department_id = departments.department_id
AND departments.location_id = locations.location_id;
OUTER JOIN. UNIONES EXTERNAS.

Antes de que existiera el estándar ISO/ANSI para uniones externas ORACLE resolvía
estas consultas mediante la sintaxis (+).
La nueva sintaxis mejora la potencia y la legibilidad del código. El (+) sólo permite
efectuar uniones externas en un único sentido, izquierdo o derecho.
Tipos de uniones externas:
• LEFT OUTER JOIN
• RIGHT OUTER JOIN
• FULL OUTER JOIN
LEFT OUTER JOIN:

Recupera las filas que tienen valor en la otra tabla y las filas de la tabla de la izquierda
que no lo tienen en la tabla de la derecha.
SELECT employee_id, department_name

FROM departments d
LEFT OUTER JOIN employees e
ON (e.department_id= d.department_id);
La sentencia anterior es equivalente a:
SELECT employee_id, department_name

FROM departments d, employees e
WHERE e.department_id(+) = d.department_id;
RIGHT OUTER JOIN:

Recupera las filas que tienen valor en la otra tabla y las filas de la tabla de la derecha
que no lo tienen en la tabla de la izquierda.
SELECT name, o.custid, orderdate

FROM ord o
RIGHT OUTER JOIN customer c
ON (o.custid = c.custid);
La sentencia anterior es equivalente a:
SELECT name, o.custid, orderdate

FROM ord o, customer c
WHERE c.custid = o.custid(+);
FULL OUTER JOIN:

Recupera las filas que tienen valor en la otra tabla y las que no, tanto las de la tabla de
la izquierda como las de la derecha.
Este es un nuevo tipo de join, que no existía en las versiones previas.
SELECT l.city, c.country_name

FROM locations l
FULL OUTER JOIN countries c
ON (l.country_id = c.country_id);
La sentencia anterior sería equivalente a una sentencia con la función de conjunto

UNION:

FROM locations l, countries c
WHERE l.country_id = c.country_id(+)
UNION
FROM locations l, countries c
WHERE l.country_id(+) = c.country_id;
LA EXPRESIÓN CASE
En el SQL: 1999 existen cuatro tipos de expresiones CASE:
• CASE simple.
• CASE buscada.
• NULLIF.
• COALESCE.
CASE SIMPLE
La expresión CASE simple es similar a la función DECODE. Es empleada para buscar y
reemplazar valores resultantes según una expresión predefinida. Se puede especificar un
valor devuelto por cada valor buscado. No se pueden emplear operadores de
comparación.
SELECT employee_id, CASE department_id

WHEN 10 THEN 'Diez'
WHEN 20 THEN 'Veinte'
WHEN 30 THEN 'Treinta'
ELSE 'Otro'
END "Departamento"
FROM employees;
Esta sentencia es equivalente a:
SELECT employee_id,
DECODE(department_id,10,'Diez',20,'Veinte',30,'Treinta', 'Otro')
"Departamento"
FROM employees;
CASE BUSCADA
La CASE buscada (searched CASE) es similar al IF..THEN..ELSE, permite buscar y
reemplazar valores condicionalmente.
Cada cláusula WHEN puede ser diferente y los operadores lógicos pueden ser usados
para combinar condiciones múltiples. Está permitido el uso de los operadores de
comparación.
SELECT employee_id,
CASE
WHEN salary >=20000 THEN 'High'
WHEN salary < 10000 THEN 'Low'
ELSE 'Medium'
END "Salary"
FROM employees;
NULLIF
Devuelve NULL si el primer argumento es igual al segundo; en caso contrario, se
devuelve el valor del primer argumento.
SELECT employee_id,
NULLIF (commission_pct,.1) "new commission"
FROM employees;
COALESCE
Devuelve el primer argumento (comenzando por la izquierda) que sea NOT NULL. Es
similar a la función NVL, pero puede tener múltiples valores alternativos. Se acepta
cualquier cantidad de argumentos.
Si la evaluación de todas las expresiones es NULL, la función COALESCE devuelve un
valor NULL.
SELECT employee_id,
COALESCE(to_char(commission_pct),'none') commission
FROM employees;
SUBCONSULTAS
Las subconsultas son sentencias SELECT que se encuentran anidadas dentro de una
CONSULTA PADRE. A las subconsultas a veces se las denomina CONSULTAS ANIDADAS. La
sentencia que contiene una subconsulta es denominada CONSULTA PADRE. Las filas que
devuelve la subconsulta son utilizadas por la consulta padre; de esta forma se consigue
establecer condiciones sin conocer previamente los valores que las determinan.
La sintaxis básica en la sentencia SELECT es la siguiente:
SELECT Lista_Columnas_o_Expresiones|*
FROM Lista_Tablas
WHERE expresión operador (SELECT Lista_Columnas_o_Expresiones|*
FROM Lista_Tablas
WHERE .....)
La expresión delante del operador en la consulta padre se debe corresponder en tipo y

cardinalidad con la lista de columnas o expresiones de la subSELECT.
Es necesario que el operador sea el adecuado para tratar el número de filas devueltas
por la subselect (p.e. elección del operador = ó IN: si devuelve más de una fila para = se
produciría un error. Si es posible esperar más de un valor devuelto se emplearía el
operador IN).
• Las subconsultas se utilizan para responder una pregunta multi-parte.
• Una subconsulta se ejecuta UNA sola vez, independientemente de las filas que
devuelva la consulta principal o consulta padre.
• Una subconsulta puede así mismo contener otra subconsulta. No hay límite en el
nivel de anidaciones de consultas.
El uso de las subconsultas va más allá de su uso en la sentencia SELECT. Se utiliza para:
• Definir el conjunto de filas que se desea insertar en la tabla destino en una
sentencia INSERT o CREATE TABLE.
• Definir el conjunto de filas que se desea incluir la vista en una sentencia CREATE
VIEW.
• Definir uno o más valores a asignar en las filas existentes en una sentencia
UPDATE .... SET.
• Proporcionar valores para condiciones en las cláusulas WHERE y HAVING de las
sentencias SELECT, UPDATE y DELETE.
Ejemplos de subconsultas de FILA SIMPLE:
SELECT last_name
FROM employees
WHERE salary >
(SELECT salary
FROM employees
WHERE last_name = 'Abel');
SELECT last_name, job_id

FROM employees
WHERE job_id =
(SELECT job_id
FROM employees
WHERE employee_id = 141);
SELECT last_name, job_id, salary
FROM employees
WHERE job_id =
(SELECT job_id
FROM employees
WHERE employee_id = 141)
AND salary >
(SELECT salary
FROM employees
WHERE employee_id = 143);
Usando funciones de grupo en una subconsulta:
SELECT last_name, job_id, salary

FROM employees
WHERE salary =
(SELECT MIN(salary)
FROM employees);
SELECT department_id, MIN(salary)

FROM employees
GROUP BY department_id
HAVING MIN(salary) >
(SELECT MIN(salary)
FROM employees
WHERE department_id = 50);
En la siguiente sentencia se produce un error al ser devueltas más de una fila por la
subconsulta y no ser adecuado el operador para el tratamiento de más de una fila.
SELECT employee_id, last_name

FROM employees
WHERE salary =
(SELECT MIN(salary)
FROM employees
GROUP BY department_id);
ERROR at line 4:
ORA-01427: single-row subquery returns more than one row
El operador adecuado para corregir el error sería IN en lugar de =.

Ejemplos con subconsultas que devuelven más de una fila:
SELECT last_name, salary, department_id

FROM employees
WHERE salary IN (SELECT MIN(salary)
FROM employees
GROUP BY department_id);
Esta sentencia, teniendo en cuenta el contenido de las tablas, sería equivalente a la siguiente:
SELECT last_name, salary, department_id

FROM employees
WHERE salary IN
(11088,3600,10080,24480,9936,8640,11952,3024,8784,9360,6048,6336);
SELECT employee_id, last_name, job_id, salary
FROM employees
WHERE salary < ANY
(SELECT salary
FROM employees
WHERE job_id = 'IT_PROG')
AND job_id <> 'IT_PROG';
Ejemplos de tratamiento de NULL en las subconsultas:

La siguiente sentencia muestra los empleados que tienen subordinados. El operador IN es
adecuado para el tratamiento de nulos entre los valores devueltos por la subconsulta.
SELECT emp.last_name
FROM employees emp
WHERE emp.employee_id IN (SELECT mgr.manager_id FROM employees mgr);
En la siguiente sentencia se recuperan los empleados que no tienen subordinados.
SELECT last_name FROM employees

WHERE employee_id NOT IN
(SELECT manager_id FROM employees
WHERE manager_id IS NOT NULL);
Siempre que haya valores nulos entre los valores devueltos por una subconsulta no emplear
el operador NOT IN pues es equivalente a <>ALL.
SELECT emp.last_name
FROM employees emp
WHERE emp.employee_id NOT IN
(SELECT mgr.manager_id
FROM employees mgr);
RECUPERACIÓN JERÁRQUICA
Utilizando recuperaciones jerárquicas se pueden recuperar datos basados en relaciones
jerárquicas entre las filas de una tabla.
En el caso de la tabla EMPLOYEES, la relación existente entre los jefes y sus empleados se
establece a través de la columna MANAGER_ID y EMPLOYEE_ID. Un jefe tiene varios
empleados, y éstos a su vez pueden ser jefes de otros empleados.
Sintaxis:
SELECT [LEVEL], columna, expr...

FROM tabla
[WHERE condición(es)]
[START WITH condición(es)]
[CONNECT BY PRIOR condición(es))];
• Level: Es el nivel que ocupa el valor dentro de la estructura jerárquica. Retorna

un number.
• Start with: Por donde queremos que empiece la jerarquía.
• Connect by: En esta cláusula, se vincula los dos campos que tienen relación
jerárquica.
• Prior: Establece niveles de jerarquía empezando por START WITH.
SELECT employee_id, last_name, job_id, manager_id
FROM employees
START WITH employee_id = 101
CONNECT BY PRIOR manager_id = employee_id;
EMPLOYEE_ID LAST_NAME JOB_ID MANAGER_ID

101 Kochhar AD_VP 100
100 King AD_PRES
En el siguiente ejemplo. Visualizar el número de empleado, nombre, trabajo, identificador

del jefe y nivel, realizando una recuperación jerárquica ordenada por niveles:
SELECT employee_id, last_name, job_id, manager_id,level

FROM employees
START WITH manager_id IS NULL
CONNECT BY manager_id = PRIOR employee_id
ORDER BY level;
EMPLOYEE_ID LAST_NAME JOB_ID MANAGER_ID LEVEL

100 King AD_PRES 1
101 Kochhar AD_VP 100 2
102 De Haan AD_VP 100 2
121 Fripp ST_MAN 100 2
120 Weiss ST_MAN 100 2
114 Raphaely PU_MAN 100 2
122 Kaufling ST_MAN 100 2
124 Mourgos ST_MAN 100 2

146 Partners SA_MAN 100 2
201 Hartstein MK_MAN 100 2
149 Zlotkey SA_MAN 100 2
148 Cambrault SA_MAN 100 2
147 Errazuriz SA_MAN 100 2
145 Russell SA_MAN 100 2
123 Vollman ST_MAN 100 2
108 Greenberg FI_MGR 101 3
204 Baer PR_REP 101 3
203 Mavris HR_REP 101 3
200 Whalen AD_ASST 101 3
...
Es posible formatear la salida en sqlplus utilizando LEVEL:
COLUMN org_chart FORMAT A12 -- Formato a columna
SELECT LPAD(last_name, LENGTH(last_name)+(LEVEL*2) -2,'_') AS org_chart

FROM employees
START WITH last_name='King'
CONNECT BY PRIOR employee_id=manager_id;
ORG_CHART
King
King
__Kochhar
____Greenber g
______Faviet
______Chen
______Sciarr a
______Urman
______Popp
____Whalen
____Mavris
DML. LENGUAJE DE MANIPULACIÓN DE DATOS

Cuando se añaden, actualizan o borran datos en una base de datos, se está ejecutando una
sentencia DML. Una colección de sentencias DML conforman una unidad lógica de trabajo
llamada transacción.
INSERT
• El propósito de la sentencia INSERT es añadir filas a una tabla o vista.
• Como requisitos para añadir filas en una tabla, la tabla debe ser propiedad del
usuario que intenta realizar la inserción o bien tener privilegio de INSERT sobre
ella.
Sintaxis:
INSERT INTO tabla [(columna [, columna...])]

VALUES (valor [, valor...]);
• Tabla: Nombre de tabla o vista donde se realiza la inserción.

• Columna: Columna/s sobre la/s que se desea realizar la inserción. Si se omiten
los nombres y el orden de las columnas, se espera que se inserten valores para
TODAS las columnas de la tabla o vista y en el orden en que fue creada.
• VALUES: Especifica un valor para la fila que se desea insertar.
En lugar de la cláusula VALUES se puede utilizar una subconsulta que recupere datos
coordinados con las columnas a insertar.
INSERT INTO tabla [(columna [, columna...])]

SUBCONSULTA;
Ejemplos de INSERT:
 Insertar una fila.
INSERT INTO departments(department_id, department_name, manager_id,

location_id)
VALUES (280, 'Jobbes', 100, 1700);
 Insertar una fila con valores nulos.
INSERT INTO departments (department_id,department_name )

VALUES (290, 'Art');
INSERT INTO departments

VALUES (300, 'Tecnology', NULL, NULL);
 Insertar valores especiales como la fecha del sistema.
INSERT INTO employees (employee_id, first_name, last_name, email,

phone_number, hire_date, job_id, salary,
commission_pct, manager_id, department_id)
VALUES (207,'Louis', 'Kunts','LKUNT', '515.124.4567',SYSDATE,'AC_ACCOUNT',
6900,NULL, 205, 100);
 Insertar datos específicos tipo fecha.
INSERT INTO employees

VALUES (214,'Den', 'Marck','DMARCK', '515.127.4561',
TO_DATE('FEB 3, 1999', 'MON DD, YYYY'),'AC_ACCOUNT', 11000,
NULL, 100, 30);
 Insertar filas procedentes de otras tablas.
INSERT INTO emp(empno, ename , sal, deptno)

SELECT employee_id, last_name, salary, 40
FROM employees
WHERE job_id LIKE '%REP%';
UPDATE
• El propósito de la sentencia UPDATE es modificar los valores existentes en una
tabla o vista.
• Como requisitos para actualizar filas de una tabla, la tabla debe ser propiedad del
usuario que intenta realizar la actualización o bien tener privilegio de UPDATE
sobre ella.
Sintaxis:
UPDATE tabla
SET columna = value [, column = valor, ...]
[WHERE condición];
• Tabla: Nombre de tabla o vista donde se realiza la actualización.

• Columna: Columna/s sobre la/s que se desea realizar la actualización. Si se
omite el nombre de alguna columna de la tabla/vista, esta permanecerá
inalterable.
• WHERE: La condición que deben cumplir las filas que se desea actualizar. Si se
omite se actualizan TODAS.
La sentencia UPDATE admite especificar subconsultas que devolverá/n los valores
nuevos que se asignarán a la columna/s correspondiente/s.
Sintaxis:
UPDATE table
SET column =
(SELECT columna
FROM tabla
WHERE condición)
[, column =
(SELECT columna
FROM tabla
WHERE condición)]
[WHERE condición];
Ejemplos de sentencias UPDATE:

 Actualizar una fila específica.
UPDATE employees
SET department_id = 70
WHERE employee_id = 113;
 Actualizar todas las filas de una tabla.

UPDATE employees
SET salary = salary*1.2;
 Actualizar una tabla mediante subconsultas.
UPDATE employees
SET job_id = (SELECT job_id
FROM employees
WHERE employee_id = 205),
salary = (SELECT salary
FROM employees
WHERE employee_id = 205)
WHERE employee_id = 114;
DELETE
• El propósito de esta sentencia, es borrar filas de una tabla o vista.
• Como requisitos para borrar filas de una tabla, la tabla debe ser propiedad del
usuario que intenta realizar el borrado o bien, tener privilegio de DELETE sobre
ella.
Sintaxis:
DELETE [FROM] tabla

[WHERE condición];
• Tabla: Nombre de tabla o vista donde se realiza el borrado de las filas.

• WHERE: La condición que deben cumplir las filas que se desean borrar. Si se
omite se borran TODAS. Esta cláusula admite subconsultas.
Ejemplos de sentencias DELETE:

 Eliminar una fila especificando una condición.
DELETE FROM departments

WHERE department_name = 'Operations';
 Eliminar todas las filas de una tabla.
DELETE FROM salgrade;
 Eliminar filas utilizando una subconsulta.
DELETE FROM employees

WHERE department_id =
(SELECT department_id
FROM departments
WHERE department_name LIKE '%Public%');
MERGE
El lenguaje SQL ha sido ampliado para incluir la sentencia MERGE. Utilizando esta
sentencia es posible actualizar o insertar una fila condicionalmente. La decisión de
actualizar o insertar la fila está basada en una condición especificada en la cláusula ON.
• Realiza un UPDATE si la fila existe y un INSERT si es una nueva fila:
 Evita UPDATES separados.
 Aumenta su funcionalidad y es fácil de usar.
 Es útil para aplicaciones de data warehousing.
Sintaxis:
MERGE INTO nombre_tabla alias_tabla

USING (tabla|vista|sub_consulta) alias
ON (condicion de join)
WHEN MATCHED THEN
UPDATE SET
col1 = valor,
col2 = valor
WHEN NOT MATCHED THEN
INSERT (lista de columnas)
VALUES (valores);
• INTO: especifica la tabla o vista objetivo sobre la que se actualiza o inserta.

• USING: identifica el origen de los datos para la actualización o inserción. Puede
ser una tabla, vista o subconsulta.
• ON: especifica la condición que utilizará MERGE para escoger la operación de
actualización o inserción.
• WHEN MATCHED | WHEN NOT MATCHED: especifica al servidor cómo actuar
ante los resultados de la condición de join. (cuando hay coincidencia o cuando no
hay coincidencia).
Ejemplo de sentencia MERGE:
• Actualizar o insertar filas en una tabla copia de EMPLOYEES llamada COPY_EMP
para hacerla coincidir las filas comunes con las de la tabla EMPLOYEES e insertar
las que no se encuentren.
MERGE INTO copy_emp c

USING employees e
ON (c.employee_id = e.employee_id)
WHEN MATCHED THEN
UPDATE SET
c.first_name = e.first_name,c.last_name = e.last_name,
c.email = e.email,c.phone_number = e.phone_number,
c.hire_date = e.hire_date,c.job_id = e.job_id,
c.salary = e.salary,c.commission_pct = e.commission_pct,
c.manager_id = e.manager_id,c.department_id = e.department_id
INSERT VALUES(e.employee_id, e.first_name, e.last_name,
e.email, e.phone_number, e.hire_date, e.job_id,
e.salary, e.commission_pct, e.manager_id,e.department_id);
SENTENCIAS TRANSACCIONALES
• Oracle Server asegura la consistencia de los datos basándose en transacciones.
Las transacciones permiten flexibilidad y control durante los cambios de los datos,
y aseguran la consistencia en el caso de que algún proceso de usuario o del
sistema falle.
• Una transacción de base de datos está provocada por una o varias sentencias tipo
DML, por sólo una tipo DDL o DCL.
• CONSISTENCIA EN LECTURA: los usuarios acceden a la base de datos de dos
formas: con operaciones de lectura (SELECT) o de escritura (DML). En función de
estos tipos de operaciones y teniendo en cuenta la concurrencia de sesiones que
acceden a los mismas tablas es necesario garantizar la consistencia de los datos
ante las siguientes consideraciones:
 Las lecturas y escrituras en la base de datos deben asegurar una vista
consistente de los datos.
 Las lecturas de una sesión no deben ver datos que estén en proceso de cambio
en otra sesión diferente.
 Las escrituras tienen que tener asegurado que los cambios que realicen sobre
la base de datos se llevan a cabo sobre datos consistentes.
 Los cambios hechos por una operación de escritura no debe entrar en conflicto
con cambios no consolidados llevados a cabo desde otra sesión.
 El objeto de la consistencia en lectura es asegurar que antes de que se ejecute
una sentencia DML en la sesión, cada usuario ve los datos consistentes, es
decir, como quedaron desde el último COMMIT que los validó en la base de
datos.
• BLOQUEO: los bloqueos son mecanismos que previenen una interacción
destructiva entre transacciones accediendo a un mismo recurso.
• Oracle implementa el bloqueo de forma automática sin requerir una acción por
parte del usuario. Este bloqueo se lleva a cabo para todas las sentencias SQL en
las que sea necesario de forma automática, excepto para la SELECT, que
requerirá de un bloqueo explícito por parte del usuario (… for update of column ).
• Una transacción comienza cuando la primera sentencia SQL DML es ejecutada
durante una sesión y finaliza cuando se produce alguno de estos eventos:
 Se ejecuta una sentencia transaccional COMMIT o ROLLBACK.
 Se ejecuta una sentencia DDL o DCL (se produce un COMMIT implícito).
 La sesión del usuario finaliza de manera anormal (fallo de sistema) o de forma
voluntaria (salida de la herramienta).
• Durante una sesión de usuario únicamente una transacción puede estar en vigor.
• Las sentencias transaccionales son:
 COMMIT
 ROLLBACK
 SAVEPOINT
COMMIT
Finaliza la transacción actual, valida todos los cambios de datos haciéndolos permanentes.
Sintaxis:
COMMIT [WORK];
• WORK: es opcional y no aporta ninguna funcionalidad.

• Al ejecutar un COMMIT, se liberan todos los o puntos de salvaguarda,
SAVEPOINT indicados hasta el momento.
• La ejecución de sentencias DDL y DCL llevan consigo un COMMIT implícito
(COMMIT automático)
SAVEPOINT
• Los puntos de salvaguarda son marcas lógicas que va poniendo el usuario durante
la transacción actual.
• Estas marcas permiten deshacer los cambios por partes en vez de deshacer toda
la transacción.
• Al ser marcas lógicas no es posible listar los puntos de salvagurarda creados.
SAVEPOINT <punto de salvaguarda>;
• Si se reutiliza un nombre de punto de salvaguarda durante la transacción, el

anterior con el mismo nombre se pierde.
• Al hacer el ROLLBACK sin parámetros o el COMMIT, se eliminan todos los puntos
de salvaguarda.
• Al hacer el ROLLBACK TO solo se borran los puntos posteriores al especificado.
• SAVEPOINT no es ESTÁNDAR ANSI SQL.
ROLLBACK
Finaliza la transacción actual y deshace todos los cambios de datos pendientes.
Sintaxis:
ROLLBACK [WORK] [TO [SAVEPOINT] punto_salvaguarda];
• ROLLBACK: deshace los cambios pendientes.

• WORK: es opcional y no aporta ninguna funcionalidad.
• TO [SAVEPOINT] <punto_salvaguarda>: deshace sólo los cambios efectuados
desde el punto de salvaguarda indicado.
• Una terminación anormal de la sesión o un fallo del sistema lleva consigo un
ROLLBACK implícito (ROLLBACK automático).
TIEMPO DE SESION CONTROL DE TRANSACCIONES
COMMIT
DELETE
SAVEPOINT A
INSERT
UPDATE
SAVEPOINT B
INSERT
ROLLBACK TO ROLLBACK TO ROLLBACK

SAVEPOINT B SAVEPOINT A
3
Lenguaje de Definición de Datos. DDL

TABLA DE CONTENIDOS
Introducción .......................................................................................................................1
Comandos DDL ..................................................................................................................1
CREATE TABLE .................................................................................................................1
Sintaxis CREATE TABLE ...................................................................................................... 1
Integridad de Datos ...........................................................................................................3
Reglas de Negocio ................................................................................................................ 3
Integridad de Entidades......................................................................................................... 3
Integridad Referencial ........................................................................................................... 4
Nombres de las Restricciones ............................................................................................... 5
Cómo Definir Una Restricción ............................................................................................... 6
Restricciones: características. ............................................................................................... 7
Comprobación de restricciones aplazada ............................................................................. 7
Restricciones obligatorias...................................................................................................... 8
Restricción UNIQUE o PRIMARY KEY utilizando un índice no único. ................................. 9
CREATE INDEX ................................................................................................................10
Tablas tipo índice ................................................................................................................ 10
CREATE SYNONYM .........................................................................................................12
CREATE VIEW ..................................................................................................................12
CREATE SEQUENCE .......................................................................................................13
ALTER TABLE ..................................................................................................................14
Añadir Restricciones ............................................................................................................ 15
Desactivar Restricciones ..................................................................................................... 15
Activar Restricciones ........................................................................................................... 16
Excepciones Activando Restricciones ................................................................................. 16
Borrar Restricciones ............................................................................................................ 18
Borrar Columnas ................................................................................................................. 18
El Comando ALTER SEQUENCE.................................................................................... 19
DROP TABLE ...................................................................................................................19
DROP INDEX ....................................................................................................................19
DROP VIEW ......................................................................................................................20
DROP SYNONYM .............................................................................................................20
DROP SEQUENCE ...........................................................................................................20
RENAME ...........................................................................................................................20
El Comando TRUNCATE ................................................................................................. 21
Lenguaje de Definición de Datos. DDL 3-1
INTRODUCCIÓN
El lenguaje DDL pertenece al lenguaje SQL y nos permite crear, modificar, renombrar y
borrar objetos dentro de la Base de Datos. Hasta ahora solo habíamos manipulado
objetos ya creados previamente.
Para poder ejecutar los comandos que veremos a continuación es necesario tener una
serie de privilegios, que el administrador de la Base de Datos ha debido concedernos
previamente.
Llevan implícito la validación o COMMIT.
COMANDOS DDL
CREATE El comando CREATE permite al usuario que lo ejecuta crear un objeto
(Tablas, índices, vistas, sinónimos, secuencias, etc.)
ALTER El comando ALTER permite al usuario que lo ejecuta modificar la estructura
de un objeto previamente creado.
DROP El comando DROP permite al usuario que lo ejecuta eliminar un objeto (no
sólo las columnas) de la Base de Datos.
RENAME Permite al usuario que lo ejecuta modificar el nombre de un objeto.
TRUNCATE Permite al usuario que lo ejecuta borrar TODAS las filas de una tabla o
índice. Tiene ciertas diferencias con DELETE o DROP que veremos
próximamente.
CREATE TABLE
Permite crear una tabla, que es la estructura básica de una base de datos.
En el momento de la creación de la tabla se puede especificar la siguiente información:
• Definiciones de columnas. (tipos de datos y longitud).
• Restricciones de Integridad.
• Características de Almacenamiento del objeto.
• Si la tabla se forma partiendo de una sentencia SELECT.
SINTAXIS CREATE TABLE
CREATE TABLE [esquema.]nombre_tabla (

COL1 tipo_Dato_col1 (longitud) [restricción_int] [,
COL2 tipo_Dato_col2 (longitud) [restricción_int],
…
COLn tipo_Dato_coln (longitud) DEFAULT [expresión]]
[, Declaración opcional de mas restricciones de integridad] )
[PARAMETROS DE ALMACENAMIENTO]
[ AS subconsulta]
El siguiente ejemplo muestra la creación de una tabla sin indicar ningún tipo de
restricción o cláusula de almacenamiento. Solamente se indican los nombres de las
columnas, a qué tipos de dato pertenecen y la longitud de las columnas.
CREATE TABLE productos (

Codigo_prod NUMBER(4),
Descripcion VARCHAR2(80));
El siguiente ejemplo muestra la creación de una tabla basada en una sentencia SELECT
CREATE TABLE control_salarios (trabajo, maxsal, minsal)

3-2 Lenguaje de Definición de Datos. DDL
AS SELECT job, MAX(salario), MIN(salario) FROM emp GROUP BY job;
Los tipos de datos que podemos definir en las columnas de nuestras tablas son:
Tipo Dato Descripción
VARCHAR2(tam) Cadena de caracteres de longitud variable. Tamaño máximo es 4000
bytes y el mínimo uno. Es obligatorio especificar precisión.
NVARCHAR2(tam) Cadena de caracteres de longitud variable teniendo un máximo de
longitud expresado en caracteres o bytes, depende del juego de
caracteres nacional indicado. El tamaño máximo se determina por el
número de bytes requerido para almacenar cada carácter. El límite
superior es 4000 bytes. Es obligatorio especificar precisión.
NUMBER (n,d) Numero de tamaño 'n' (hasta 38) conteniendo 'd' decimales (de -84 a
127)
LONG Cadena de caracteres de longitud variable. Tamaño hasta 2 Giga
bytes. Solo puede haber uno por tabla. No pueden tener restricciones
de integridad. No pueden utilizarse en cláusulas WHERE, GROUP BY,
CONNECT BY, DISTINCT, ni consultas anidadas ni operadores de
conjuntos.
DATE Fecha mostrada con la máscara 'DD-MES-AA”. Depende variables
"NLS". Siete bytes numéricos.' Rangos válidos son desde 1 de Enero
de 4712 Después de Cristo a 31 de Diciembre de 4712 Antes de
Cristo.
RAW(tam) Dato binario de longitud variable. Tamaño máximo 2000 bytes. Se
debe indicar precisión.
LONG RAW Cadena binaria de longitud variable de hasta 2 Gigabytes.
ROWID Cadena hexadecimal que representa la dirección única de una fila en
una tabla. Este tipo de dato se utiliza para almacenar los valores
devueltos par la pseudocolumna ROWID.
CHAR(tam) Cadena alfanumérica de longitud fija. Tamaño máximo 2000 bytes. Si
no se indica precisión el valor mínimo y valor por defecto es 1 byte.
NCHAR(tam) Cadena alfanumérica de longitud fija. Teniendo un máximo de
longitud expresado en caracteres o bytes, depende del juego de
caracteres nacional indicado. El tamaño máximo se determina por el
número de bytes requerido para almacenar cada carácter. El límite
superior es 2000 bytes. Si no se indica precisión el valor mínimo y
valor por defecto es 1 byte.
MLSLABEL Formato binario y etiquetado bajo el sistema operativo. Ese tipo de
dato aparece por compatibilidad hacia trastas en “Oracle Trusted”.
CLOB Objeto grande tipo carácter conteniendo caracteres de byte simple.
No se soportan juegos de caracteres de tamaño variable. Máximo 4
gigabytes.
NCLOB Objeto grande tipo carácter conteniendo caracteres multibyte de
tamaño fijo. No se soportan juegos de caracteres de tamaño variable.
Máximo 4 gigabytes
BLOB Un objeto grande binario. Tamaño máximo 4 Gigabytes.
BFILE Contiene un localizador a un fichero binario almacenado fuera de la
base de datos. Tamaño máximo 4 gigabytes.
BINARY_FLOAT Este tipo de datos existe a partir de Oracle 10g, almacenan datos
numéricos de coma flotante en formato IEEE 754 de 32 bits de
precisión.
BINARY_DOUBLE Este tipo de datos existe a partir de Oracle 10g, almacenan datos
numéricos de coma flotante en formato IEEE 754 de 64 bits de
precisión.
La información acerca de las tablas y columnas en el diccionario de datos, se encuentra
en las siguientes vistas del diccionario accesibles para cualquier usuario:
• USER_TABLES y ALL_TABLES
• USER_TAB_COLUMNS y ALL_TAB_COLUMNS
INTEGRIDAD DE DATOS
Antes de definir una tabla debemos tener en cuenta ciertos aspectos acerca de la
información a almacenar que nos evitan tener que programar de forma redundante
ciertas comprobaciones.
La declaración de restricciones de integridad nos ayuda a definir ciertas características de
la tabla. Por ejemplo, si una columna puede estar vacía o no, si puede contener valores
duplicados, si está relacionada con alguna columna de otra tabla, etc.
La integridad de datos por lo tanto es:
• Asegurarse que los datos en las tablas se ajustan a una serie de reglas
predefinidas.
• Las condiciones se cumplen en todas las transacciones y desde todas las
herramientas y programas.
• Se definen una sola vez y no necesitan mantenimiento especial.
Conceptos de integridad que se pueden definir:
• Reglas negocio.
• Integridad de entidades.
• Integridad referencial.
REGLAS DE NEGOCIO
Específica cada área de negocio. Por ejemplo: Sólo cuando se venden 10 productos o
más hay derecho a descuento.
INTEGRIDAD DE ENTIDADES
Reglas a las que deben ajustarse las columnas de mis tablas. Pueden definirse las
siguientes:
• NOT NULL. La columna a la que se aplique esta restricción debe contener
valores. Por ejemplo: la columna número de Identificación fiscal de la tabla
facturas.
• PRIMARY KEY. Identificador único de una fila en una tabla. Solo puede haber
una por tabla, pero puede estar compuesto por más de una columna. Se utiliza de
forma habitual para ser referenciada desde otra tabla. Al definir una columna
como clave primaria de forma implícita, se crea un índice asociado y la columna
quedará definida como única y obligatoria si no se crea desactivado. Lleva
incluida la restricción NOT NULL.
Por ejemplo, el código de un producto es su identificativo en la tabla de los
productos y además le ayuda a relacionarse con la tabla que contiene los precios
de los productos o con la de almacén que contiene la cantidad de un producto que
nos queda en stock.
• UNIQUE. No puede haber más de dos filas con el mismo valor en aquella
columna/s que tenga dicha restricción. Puede ser simple o compuesta de varias
columnas. A diferencia de la clave primaria, no es obligatoria y además puede
haber más de una por tabla. Si se quiere trabajar bajo normativa ANSI/ISO la
columna que lleve esta restricción deberá tener adicionalmente la restricción NOT
NULL.
Por ejemplo, una restricción de unicidad sobre el código de una película y el
número de copia en la tabla prestamos_videos.
• CHECK. Restricción que realiza un filtro sobre las filas que no cumplan la
condición impuesta. Es similar a la cláusula WHERE pero se implementa en la
definición del objeto. No puede incluir subconsultas ni variables o
pseudocolumnas (USER, SYSDATE, etc).
Por ejemplo: Comprobar que el precio de un producto es mayor que cero.
INTEGRIDAD REFERENCIAL
Es la que determina las relaciones existentes entre los objetos. Por ejemplo existe una
relación entre las tablas Locations y Countries.
• PRIMARY KEY (Clave primaria). Identificador único de una fila en una tabla.
Hemos visto anteriormente que este concepto pertenece a la integridad de
entidades.
• FOREIGN KEY. Columna normalmente asociada a una clave primaria o única de
otra tabla o de la misma tabla (denominado auto-referencia). Puede haber tantas
como se desee por tabla. Su valor puede ser nulo o el valor de la clave
referenciada. Garantiza consistencia de relaciones entre los datos.
Por ejemplo: Toda línea de factura debe tener su cabecera, o lo que es lo mismo,
debe pertenecer a una línea de factura.
Estableciendo estas relaciones entre claves ajenas y primarias logramos:
• Evitar borrados, inserciones o actualizaciones no deseadas: Por ejemplo, no se
puede borrar una factura que tiene líneas. No se puede dar de alta una línea de
factura sin su correspondiente cabecera. No se puede actualizar el identificativo
de una línea de factura.
Propagar Modificaciones. Lo contrario a lo anterior. Se pueden definir acciones de
borrado en cascada. Por ejemplo, si se borra una cabecera de factura que se borren las
correspondientes líneas usando ON DELETE CASCADE. ON DELETE SET NULL coloca nulos
todas las claves secundarias relacionadas con la borrada.
DEFAULT. No es una restricción en sí, pero que proporciona la posibilidad de indicar un

valor por defecto a columnas que no se mencionan en un INSERT. Admite variables del
sistema como USER, UID o SYSDATE. Por ejemplo, la fecha de emisión de una factura es
una columna tipo DATE y si no se le indica un valor explícitamente, tendrá el de la fecha
del sistema.
La sentencia CREATE TABLE se utiliza para establecer todas las relaciones y reglas
anteriormente citadas. Es la llamada sintaxis declarativa. Véase el siguiente ejemplo.
CREATE TABLE depart (

Deptno NUMBER(2) CONSTRAINT cp_dept PRIMARY KEY,
Dname VARCHAR2(13) UNIQUE NOT NULL,
Loc VARCHAR2(13) );
CREATE TABLE emple (

Empno NUMBER(4) CONSTRAINT cp_emp PRIMARY KEY,
Ename VARCHAR2(13),
…
Deptno NUMBER(2) CONSTRAINT ca_emp_deptno
REFERENCES depart(deptno) ON DELETE CASCADE);
Se puede establecer la especificación de restricciones según el siguiente ejemplo. Para

una gestión bancaria crear la tabla préstamos con todas sus restricciones y reglas.
CREATE TABLE prestamos (

Nocuenta NUMBER(6) CONSTRAINT nn_pres_nocuenta NOT NULL,
Noprestamo NUMBER(6) CONSTRAINT nn_pres_noprestamo NOT NULL,
Tipopres VARCHAR2(8) CONSTRAINT ck_pres_tipopres
CHECK (tipopres IN (‘PERS’, ‘CASA’, ‘COCHE’)),
cantidad NUMBER(8,0) CONSTRAINT nn_prest_cantidad NOT NULL,
fechapres DATE DEFAULT sysdate,
aprobadopor VARCHAR2(15) CONSTRAINT ca_prest_aprobadopor
REFERENCES jefes(nombre_dir),
CONSTRAINT cp_pres PRIMARY KEY (nocuenta, noprestamo),
CONSTRAINT ca_pres_cuenta FOREIGN KEY (nocuenta)
REFERENCES clientes (nocuenta));
NOMBRES DE LAS RESTRICCIONES

• Es un nombre único, definido bien por el propietario del objeto o por el sistema.
Si lo define el propietario del objeto en el momento de definir la restricción, debe
ir precedido de la palabra CONSTRAINT nombre_restricción tipo_restricción.
• Si no se le asigna en el momento de la creación, el sistema generará uno por
defecto: SYS_C00n.
• En el ejemplo anterior se ha utilizado una notación para nombrar las
restricciones.
La sintaxis es la siguiente:
Codigorestricción_nombretabla_nombrecolumna
Donde el Código de restricción puede ser:

• CP = CLAVE PRIMARIA
• UQ = UNICIDAD
• CA = CLAVE AJENA
• CK = CHECK
• NN = OBLIGATORIO
El nombre de la restricción aparecerá en los mensajes de error, en la documentación, al
activarla y desactivarla temporalmente o para borrarla.
La información acerca de las restricciones definidas por el usuario, y sobre qué columnas
han definido se encuentra en las siguientes tablas del diccionario de datos
USER_CONSTRAINTS o USER_CONS_COLUMNS
CÓMO DEFINIR UNA RESTRICCIÓN

Hay dos formas de definir restricciones: "En línea" o "No en línea".
• Definir una restricción "En línea", significa que la restricción va a continuación del
nombre de la columna, el tipo de dato y la precisión. En este caso, no es
obligatorio darles un nombre con la palabra clave CONTRAINT, pero se generará
uno por defecto. Por ejemplo:
CREATE TABLE facturas (
…
Num_fra NUMBER(6) [CONSTRAINT nombre] PRIMARY KEY,
…);
• Definir una restricción "No en línea" significa que la restricción/es va/n antes o
después de empezar a definir las columnas. En este caso es obligatorio preceder
la restricción con la palabra clave CONSTRAINT para que el gestor distinga entre
lo que es la definición de la columna o la declaración de la restricción. En este
caso la sintaxis varía, y se define de este modo:
CONSTRAINT nombre_restricción TIPO_RESTRICCIÓN (col1 [,…,coln])
Al definir una restricción NO EN LINEA, hay que indicar a qué columna/s de la tabla se
aplica la restricción, puesto que no esta a continuación de la definición. En ciertos casos,
como cuando una clave primaria esta compuesta de varias columnas, o cuando una
restricción se añade a posteriori, es obligatorio definirlas como NO EN LINEA.
A continuación se muestra un ejemplo de restricción NO EN LINEA:
CREATE TABLE facturas (

numero_factura NUMBER(6),
columnaN TIPO_DATO(PRECISION),
CONSTRAINT cp_facturas_numerofactura PRIMARY KEY (numero_factura),
CONSTRAINT …
…);
RESTRICCIONES: CARACTERÍSTICAS.
• La comprobación de restricciones puede aplazarse hasta el final de cada
transacción, permitiendo violaciones temporales de las restricciones.
• Cuando una restricción es diferida, el sistema comprueba si satisface la condición
en tiempo de validación (commit). Si se viola la restricción la validación causa
que la transacción entera se deshaga.
• Cuando una restricción es inmediata, se comprueba para cada sentencia. Si la
restricción se viola, la sentencia se deshace.
• Las restricciones pueden forzarse instantáneamente. Los usuarios pueden leer y
modificar datos mientras se activa la comprobación de la restricción.
• Aunque una restricción esté activada o desactivada, las restricciones pueden
activarse, desactivarse o forzarse. Una restricción forzada se comporta como si la
restricción estuviera activa, pero no garantiza que todos los antiguos datos
cumplan la restricción.
• Una restricción activa está comprobada y validada.
• Las claves primarias y únicas pueden implementarse con índices no únicos. Las
comprobaciones se comprueban al final de cada sentencia o de cada transacción.
La columna clave primaria o única debe ser la parte conductora del índice.
COMPROBACIÓN DE RESTRICCIONES APLAZADA

• Cuando se crea una tabla, las restricciones pueden utilizar:
Claves que determinan si una restricción puede comprobarse en diferido o no:
 NOT DEFERRABLE (valor por defecto)
 DEFERRABLE
Claves que determinan el comportamiento por defecto de una restricción.
 INITIALLY IMMEDIATE (valor por defecto)
 INITIALLY DEFERRED
• Cuando una restricción es diferida, el sistema comprueba si satisface la condición
en tiempo de validación (COMMIT). Si se viola la restricción la validación causa
que la transacción entera se deshaga. Cuando una restricción es inmediata, se
comprueba para cada sentencia. Si la restricción se viola, la sentencia se
deshace. Cuando se define una restricción puede crearse DEFERRABLE o NOT
DEFERRABLE.
Si una restricción se ha definido como NOT DEFERRABLE, no puede cambiarse a diferida.
Si una restricción se define como DEFERRABLE, pero es INITIALLY IMMEDIATE dentro de
cada transacción, se puede utilizar la nueva sentencia SET CONSTRAINT
nombre_restricción/ALL DEFERRED para aplazar la comprobación de restricciones.
Si una restricción se define como DEFERRABLE, pero es INITIALLY DEFERRED, se puede
utilizar el comando SET CONSTRAINT nombre_restricción IMMEDIATE para que la
restricción no se compruebe aplazada.
• El comando SET CONSTRAINT afecta solo a la transacción actual. Existe también
el comando ALTER SESSION SET CONSTRAINTS=DEFERRED para aplicarlo a toda
la sesión.
• El comportamiento por defecto de las restricciones es el siguiente:
 INITIALLY IMMEDIATE. La comprobación de la restricción no es diferida.
Significa que si se desea, hay que indicar bien SET CONSTRAINT o bien ALTER
SESSION para aplazar la comprobación.
 INITIALLY DEFERRED realiza comprobación aplazada, por lo que no se necesita
ni SET CONSTRAINT ni ALTER SESSION.
-- COMPROBACIÓN APLAZADA DE RESTRICCIONES

CREATE TABLE cuentas(
no_cta NUMBER(10) CONSTRAINT CP_NOCTA PRIMARY KEY
DEFERRABLE INITIALLY IMMEDIATE,
cliente_id NUMBER(10));
CREATE TABLE ventas(
no_cta NUMBER(10) CONSTRAINT CA_NOCTA REFERENCES cuentas
DEFERRABLE INITIALLY IMMEDIATE,
persona VARCHAR2(30),
cantidad_vendida NUMBER(8) NOT NULL,
no_semana NUMBER(2) NOT NULL);
ALTER SESSION SET CONSTRAINT=DEFERRED;

INSERT INTO ventas VALUES (1000,’JOSE M.’,1000000,32);
INSERT INTO cuentas VALUES (1000, 2777);
COMMIT;
• El ejemplo muestra como aplazar la comprobación de restricciones violando una

relación clave ajena/clave primaria.
• Se crean dos tablas ambas con la opción de aplazar la comprobación de
restricciones en la definición de las claves ajenas e inmediatas.
RESTRICCIONES OBLIGATORIAS
Desactivada Obligatoria Activada
•
•
•
•
Todos los datos de

No se comprueba la tabla y los
la restricción. nuevos datos
Los datos se añadidos y/o
comprueban modificados deben
Los datos existentes
cuando se activa cumplir la
pueden violar la
la restricción. restricción, pero NO restricción.
pueden hacerlo los
nuevos datos
insertados o
modificados.
• Una restricción puede estar desactivada, activada, o obligatoria. Una restricción

obligatoria (enforced) actúa como una activa, solo que no garantiza la integridad
de la información ya existente.
• Para que una restricción sea obligatoria se debe utilizar la sentencia ALTER TABLE
ENFORCE CONSTRAINT nombre_restricción.
• Una vez que la restricción esta obligatoria, se puede activar sin bloqueos. Puede
activarse mientras que los usuarios están actualizando o consultando las tablas
involucradas.
• Se pueden fijar restricciones obligatorias múltiples concurrentemente.
• Las restricciones obligatorias se utilizan para restricciones de unicidad con índices
existentes únicos o no únicos.
RESTRICCIÓN UNIQUE O PRIMARY KEY UTILIZANDO UN ÍNDICE NO ÚNICO.
CREATE TABLE cuentas(

no_cta NUMBER(10),
cliente_id NUMBER(10),
comentario VARCHAR2(200),
CONSTRAINT cp_cid_aid PRIMARY KEY(cliente_id, no_cta)DISABLE);
CREATE INDEX I_NCTA_CLI_COMENT

ON cuentas(no_cta, cliente_id, comentario);
• Una clave primaria o única, puede obligarse a implementarse mediante un índice

no único.
• El índice no único debe crearse con las columnas que componen la clave primaria
(en cualquier orden) como la primera columna de un índice no único. Esto elimina
la necesidad de índices redundantes e incrementa la velocidad al activar el índice
de una clave primaria o única.
• El índice no único no tiene que seguir el orden de las columnas en la clave
primaria o única. El índice utilizado para forzar una clave primaria o única no
puede borrarse.
• Cuando se desactiva una restricción de unicidad o clave primaria implementada
por un índice no único, el índice no se borra.
• Oracle puede crear índices no únicos para claves primarias y únicas.
Ejemplo:
• Cuando la restricción está activa no tiene creado un índice único pero puede
obligar la unicidad mediante el índice no único I_NCTA_CLI_COMENT.
CREATE INDEX
Los índices se utilizan para acceder más rápidamente en lectura a un dato. Para que una
columna se indexe debe cumplir ciertos requisitos:
• Ser consultada con frecuencia
• No sufrir alteraciones de operadores o funciones cuando se consulta
• Contener un volumen importante de información.
• Tener muchos valores diferentes....
Los índices pueden ser simples o compuestos de varias columnas.
Los índices pueden ser únicos o no. Si un índice se define como único, significa que no
puede tener valores repetidos.
Las restricciones UNIQUE y PRIMARY KEY llevan implícita la creación del índice si no se
crean desactivadas y que en ambos casos es único.
CREATE [UNIQUE] INDEX nombre_indice ON tabla (col1 [,col2])

STORAGE … (cláusula de almacenamiento)
CREATE INDEX ape_idx ON employees (last_name)
Las tablas del diccionario de datos con información acerca de índices accesibles para el
usuario son:
• USER_INDEXES y ALL_INDEXES
• USER_IND_COLUMNS y ALL_IND_COLUMNS
TABLAS TIPO ÍNDICE
ROWID +
Datos
de las
columnas
indexadas Datos por clave
primaria
Datos
Tabla/Índice Regular Tabla tipo índice
Hasta Oracle8i y en la mayoría de las tablas en Oracle8i:

 Los datos se almacenan en bloques de datos, sin orden.
 Los índices se mantienen como estructuras en árbol B.
• Las entradas del índice contienen.
 El valor indexado.
 El ROWID de las filas que contienen el valor.
• Esta organización es muy eficiente con la mayor parte de los datos, pero tiene
algunas desventajas.
 Oracle debe leer primero el bloque de índices y después los datos.
 Los valores claves se almacenan en ambos sitios (tabla e índice). Esto es
especialmente costoso en sistemas con gran cantidad de índices concatenados,
donde los valores clave son grandes.
• Las aplicaciones que utilizan datos complejos tienen diferentes requerimientos de
índices.
• Empleando tablas tipo índice:
 Guarda todos los bloques en una estructura en árbol B. No hay bloques de
datos separados, sólo de índices.
 Este tipo de tablas se utiliza en aplicaciones que acceden y manipulan datos
complejos. Aplicaciones informativas, aplicaciones espaciales, y aplicaciones
que realizan procesos analíticos.
Sintaxis:
CREATE TABLE esquema.nombre_tabla (

…
COLn tipo_Dato_coln (longitud) DEFAULT [restricción_int]
[, declaración opcional de mas restricciones de integridad] )
[ORGANIZATION HEAP|INDEX|EXTERNAL]
[ PARAMETROS DE ALMACENAMIENTO ]
[ AS subconsulta]
• Para crear una tabla tipo índice solamente es necesario añadir la clave
ORGANIZATION INDEX a la sentencia CREATE TABLE. La opción por defecto es
ORGANIZATION HEAP. (Apilada).
• La tabla está indexada, y después los datos se ordenan por la columna que se
haya definido como clave primaria.
Nota: No es la sintaxis completa de CREATE TABLE. La opción EXTERNAL hace referencia
a la creación de una tabla de solo lectura ubicada fuera de la base de datos.
Ejemplo:
CREATE TABLE docindice (

llamada CHAR(20),
doc_oid NUMBER,
numero_llamada NUMBER,
fecha_llamada VARCHAR2(512),
CONSTRAINT pk_docindice PRIMARY KEY (llamada, doc_oid))
ORGANIZATION INDEX;
Las tablas tipo índice tienen una serie de restricciones:

• Deben tener una clave primaria. Es el identificador único que se utiliza como base
para la ordenación. No hay ROWID para actuar como identificador único.
• Esta característica significa que no se puede actualmente crear otros índices
sobre la tabla, o utilizar restricciones de unicidad, que también se implementan
con índices.
• Las tablas tipo índice no pueden incluir columnas tipo LONG, pero SI pueden
contener LOBs.
• Las aplicaciones NO pueden recuperar o manipular vía ROWID, porque no hay
ROWID.
NOTA: Existen otras restricciones sobre estas tablas que afectan al administrador de B.D.
al realizar un ajuste de la misma, o que pertenecen a otras opciones de compra
adicionales al Gestor Oracle.
CREATE SYNONYM
Un sinónimo es un nombre alternativo a una tabla, vista o procedimiento almacenado. A
diferencia del alias, el sinónimo no es temporal y permanece hasta que es borrado.
Independientemente de la creación del sinónimo es necesario tener acceso al objeto
sobre el que se desea crear dicho sinónimo, o bien ser su propietario.
Existen dos tipos de sinónimos: públicos y privados. Los públicos están accesibles por
cualquier usuario de la Base de Datos y para crearlos se necesita el privilegio CREATE
PUBLIC SYNONYM. Los privados son accesibles sólo para aquel usuario que lo crea y se
necesita el privilegio CREATE SYNONYM.
CREATE [PUBLIC] SYNONYM sinónimo FOR [esquema.]objeto

CREATE SYNONYM miemp FOR pepe.employees
usuario son USER_SYNONYMS y ALL_SYNONYMS
CREATE VIEW
Una vista es una tabla lógica basada en una o varias tablas. La tabla no se crea
físicamente sino que lo que se almacena es la SELECT de creación de la vista.
Cuando se recuperan filas de una vista, ocurre que se accede a la sentencia SELECT que
la compone y que se encuentra almacenada, y se ejecuta.
CREATE [OR REPLACE] [FORCE|NOFORCE] VIEW nombre_vista

[(col1, coln.....)]
AS subconsulta
[ WITH CHECK OPTION | WITH READ ONLY ]
• OR REPLACE - Recrea la vista si ya existe. Esto permite cambiar la

definición de la vista sin tener que borrarla y volver a crearla.
• FORCE - Crea la vista incluso si hay problemas de acceso por insuficientes
privilegios a los objetos de la subconsulta en que se basa la creación de la vista.
• NOFORCE - Es la opción por defecto y no crea la vista si se producen errores en
la definición.
• WITH CHECK OPTION - Si la vista permite inserciones, comprobará la condición
WHERE impuesta, no solo en el momento de componer la vista, sino también a la
hora de realizar inserciones sobre ella.
A continuación se muestra un ejemplo:
CREATE VIEW sueldos AS SELECT employee_id, salary

FROM employees
WHERE department_id between 10 AND 60
WITH CHECK OPTION;
Sobre una vista no existen restricciones en consulta, pero sí en actualización inserción y

borrado. Si se cumplen las condiciones impuestas la actualización, inserción o borrado se
lleva a cabo sobre la tabla base sobre la que se definió la vista.
Para que una vista sea actualizable (permita UPDATE), NINGUNA de las columnas que
forman la vista puede estar modificada por una expresión. P.e. Substr(first_name, 1,3).
Para que la vista permita inserciones (INSERT INTO vista), la vista en su definición debe
contener TODAS las columnas obligatorias de la tabla que la forma.
Para que la vista permita borrado de filas (DELETE FROM vista), la vista debe estar
creada sobre UNA sola tabla (no admite join). No puede incorporar cláusulas DISTINCT ni
GROUP BY. No puede ser definida con funciones de grupo ni pseudocolumnas (SUM(sal) o
ROWID).
usuario son USER_VIEWS y ALL_VIEWS
CREATE SEQUENCE
Una secuencia es un objeto que permite generar números secuenciales enteros y únicos.
Esto puede ser muy útil, por ejemplo, para conseguir claves primarias de forma
automática. Además y dado que es un objeto como otro cualquiera de la Base de Datos,
puede ser utilizado por múltiples usuarios. Para poder crear una secuencia, se debe
poseer un privilegio denominado CREATE SEQUENCE.
CREATE SEQUENCE [esquema.]nombre_de_secuencia

START WITH entero
INCREMENTE BY entero
MAXVALUE entero
NOMAXVALUE
MINVALUE entero
NOMINVALUE
CYCLE
NOCYCLE
CACHE | NOCACHE ;
• START WITH - Determina el primer número secuencial que será generado.

• INCREMENT BY - Determina el salto entre los números secuenciales. Puede ser
un entero negativo o positivo. De ese modo, hacemos secuencias ascendentes o
descendentes. No puede ser 0.
• MINVALUE Determina el valor mínimo de la secuencia.
• NOMINVALUE Valor de 1 para las secuencias ascendentes y -(1026) para las
descendentes.
• MAXVALUE - Valor máximo que genera la secuencia.
• NOMAXVALUE - Valor de 1027 para las ascendentes y -1 para las descendentes.
• CYCLE- La secuencia entra en un ciclo cuando alcanza su valor máximo o
mínimo.
• NOCYCLE - Si se alcanza el valor máximo o mínimo, no se pueden generar más
números.
• CACHE - Almacena o no un número determinado de valores en memoria cache
Por ejemplo, para crear una secuencia llamada seq1 que comience por 100 y vaya
generando número de cinco en cinco se usa la orden:
CREATE SEQUENCE seq1 START WITH 100 INCREMENT BY 5;
Una vez que se ha creado la secuencia puede ser accedida utilizando dos
pseudocolumnas:
• CURRVAL devuelve el valor actual de la consulta
• NEXTVAL incrementa el valor de la secuencia
La siguiente orden incrementa la secuencia y devuelve el valor actual. CURRVAL devuelve

el valor de la secuencia, pero sin incrementar la misma.
SELECT seq1.NEXTVAL FROM DUAL;
Ambas funciones pueden ser utilizadas en:

• Una consulta SELECT que no lleve DISTINCT, ni grupos, ni sea parte de una vista,
ni sea subconsulta de otro SELECT, UPDATE o DELETE
• Una subconsulta SELECT en una instrucción INSERT
• La cláusula VALUES de la instrucción INSERT
• La cláusula SET de la instrucción UPDATE
No se puede utilizar como valor para la cláusula DEFAULT de un campo de tabla.
Evidentemente, puede ser más útil en órdenes de tipo INSERT, como por ejemplo:
INSERT INTO expedientes (codigo) VALUES (ejemplo.nextval);
usuario son USER_SEQUENCES y ALL_SEQUENCES
ALTER TABLE
El comando ALTER TABLE permite modificar la estructura de una tabla para:
• Añadir columnas a una tabla ya creada
• Modificar el tipo de dato o la precisión de una columna.
• Añadir, activar o desactivar temporalmente y borrar restricciones de integridad
referencial sobre la tabla.
• Borrar columnas de una tabla.
ALTER TABLE [esquema.]nombre_tabla

ADD | MODIFY | DROP {CONSTRAINT | COLUMN | (columna1[…, columnan])}|
{DISABLE | ENABLE} CONSTRAINT | RENAME COLUMN | …
Mediante el siguiente ejemplo, es posible añadir una columna a la tabla de

departamentos que contenga el número de empleados que trabaja en un departamento.
ALTER TABLE employees

ADD (no_empleados NUMBER(4));
Modificar la longitud de la columna “ename” en “emp” de 10 posiciones a 14. Añadir la

característica de obligatoriedad a esta misma columna.
ALTER TABLE emp

MODIFY (ename VARCHAR2(14) NOT NULL);
Para realizar esta operación debo asegurarme de que la columna ename no tiene valores
nulos. Si lo estuviera el comando ALTER TABLE devuelve un error.
Eliminar una restricción de unicidad llamada UQ_DNAME sobre la columna DNAME
mediante dos variaciones del comando ALTER TABLE.
ALTER TABLE dept

DROP CONSTRAINT uq_dname;
ó
ALTER TABLE depat
DROP CONSTRAINT UNIQUE(dname);
AÑADIR RESTRICCIONES
Se pueden añadir restricciones de integridad referencial a posteriori. En el momento que
se añade, se bloquea toda la tabla y se produce la comprobación de la restricción que se
desea incorporar. Si alguna fila no la cumple, la restricción no se añade.
Mediante el siguiente ejemplo añadir una restricción a la tabla DEPT. La situación de los
departamentos (LOC) debe ser única.
ALTER TABLE departments

ADD CONSTRAINT uq_dept_loc UNIQUE (location_id);
La sintaxis para añadir restricciones una vez creada la tabla es similar a la de las
restricciones "No en línea". Esto significa que se debe de indicar tras el comando ALTER
TABLE la palabra clave CONSTRAINT seguida de un nombre (obligatorio) luego el tipo de
restricción a aplicar, y por último sobre qué columna de la tabla se desea aplicar dicha
restricción.
Añadir una restricción en la tabla línea de facturas. Cada vez que se borre una cabecera
de factura se borran las líneas asociadas en cascada. Nótese que la restricción no se
Aplica en la tabla maestra (en este caso la de cabeceras de facturas) sino en la DETALLE
(en este caso la de líneas)
ALTER TABLE linea_fac

ADD CONSTRAINT ca_li_fact_idfact FOREIGN KEY (idfact)
REFERENCES facturas ON DELETE CASCADE;
Cuando se borre una factura, (DELETE FROM facturas WHERE idfactura=2344) se visualiza
el mensaje "N rows deleted" que se refiere a las cabeceras, aunque se hayan borrado
una cabecera y sus siete líneas.
Cuando se define una clave ajena se puede hacer referencia explícita a la tabla
referenciada REFERENCES tabla (col), o implícita REFERENCES tabla. En el caso del
borrado en cascada la sintaxis sólo permite referencia implícita.
DESACTIVAR RESTRICCIONES
El desactivar una restricción permite que dicha restricción no se compruebe
temporalmente. NO ES IGUAL que borrar la restricción.
Es la forma de incrementar la velocidad en cargas de datos masivas.
Loader (la herramienta de carga ORACLE), deshabilita automáticamente con su método
directo «direct path».
Cuando se intenta desactivar una clave ajena o clave única (que pueden ser
referenciadas), primero habrá que desactivar las claves ajenas que le referencian o
utilizar DISABLE CASCADE.
Al desactivar una clave primaria o única también se destruyen los índices asociados.
►►─── ALTER TABLE ───┬────────────┬─ tabla ─── DISABLE ────────►
└─ esquema. ─┘
┌───── , ────┐
►──┬── UNIQUE ( ─▼── columna ─┴─ ) ─┬──┬────────────┬─────────►◄
├── PRIMARY KEY ─────────────────┤ └─ CASCADE ──┘
└── CONSTRAINT restricción ──────┘ ▲
│
│
│
┌──────┴────────────┐
│ DESACTIVA TODAS │
│ LAS DEPENDENCIAS │
│ ASOCIADAS │
└───────────────────┘
ACTIVAR RESTRICCIONES
Activa la comprobación de la restricción. En el momento de la creación de una restricción
se activa a no ser que se indique la cláusula DISABLE.
Cuando se activa posteriormente:
• Bloquea la tabla completa hasta que se termine la comprobación.
• Comprueba una a una las filas.
• Si alguna de las filas no cumple la restricción, no podrá llegar a activarse.
Al habilitar una clave primaria o única se vuelven a construir los índices asociados.
►►─── ALTER TABLE ───┬────────────┬─ tabla ─── ENABLE ────────►
└─ esquema. ─┘
┌───── , ────┐
►──┬── UNIQUE ( ─▼── columna ─┴─ ) ─┬─────────────────────────►◄
├── PRIMARY KEY ─────────────────┤
└── CONSTRAINT restricción ──────┘
►───┬────────────────────────────────────────────────────────┬─►
│ │
└── USING INDEX ──┬──────────────────────────────────────┘
├─ INITTRANS entero
├─ MAXTRANS entero
├─ TABLESPACE tablespace
├─ STORAGE almacenamiento
├─ PCTFREE entero
└─ PCTUSED entero
EXCEPCIONES ACTIVANDO RESTRICCIONES

Cuando se intenta activar una restricción y no se puede, por cada fila que no cumpla la
restricción se puede guardar en una tabla creada previamente la siguiente información:
• ROWID.
• Nombre de restricción que no se cumple.
• Nombre de la tabla en la que se encuentra la restricción.
• Usuario propietario de la tabla.
La tabla EXCEPTIONS se ha creado previamente en SQL*Plus utilizando un fichero que se

encuentra en la instalación y se llama UTLXCPT.SQL y cuya estructura es:
CREATE TABLE exceptions (

row_id ROWID,
owner VARCHAR2(30),
table_name VARCHAR2(30),
constraint VARCHAR2(30) );
En el siguiente ejemplo se ha desactivado la clave primaria que existía sobre la tabla

préstamos. Después se ha introducido 1 fila duplicada. A continuación se intenta activar
de nuevo la restricción:
ALTER TABLE prestamos

ENABLE CONSTRAINT cp_prest
EXCEPTIONS INTO exceptions;
SELECT * FROM exceptions WHERE CONSTRAINT = 'CP_PREST';
ROWID OWNER TABLE_NAME CONSTRAINT

------------------ ----- ---------- ----------
AAAAeDAACAAAAERAAA PEPE PRESTAMOS CP_PREST
AAAAeDAACAAAAERAAF PEPE PRESTAMOS CP_PREST
La tabla sobre la cual se han definido las restricciones y no pueden activarse, puede
actualizarse a partir de los resultados almacenados en la tabla EXCEPTIONS.
Mediante el siguiente ejemplo, es posible averiguar qué filas están duplicadas en la tabla
borrando todas las filas duplicadas de la tabla préstamos.
SELECT p.ROWID, p.nocuenta, p.noprestamo

FROM prestamos p, exceptions WHERE p.ROWID = exceptions.row_id;
ROWID NOCUENTA NOPRESTAMO
------------------ -------- ----------
AAAAeDAACAAAAERAAA 7499 2495
AAAAeDAACAAAAERAAF 7499 2244
A continuación debemos borrar los duplicados de la tabla préstamo. Si las dos filas son
EXACTAMENTE iguales, la única forma de eliminar duplicados es utilizar el ROWID de la
fila en la tabla.
DELETE FROM prestamos WHERE noprestamo=2244; o

DELETE FROM prestamos WHERE ROWID=’AAAAeDAACAAAAERAAF’;
Insertar un valor admisible en campos con valor desconocido. Al crear la tabla la

restricción se ha creado desactivada:
CREATE TABLE prestamos (

…
CONSTRAINT ck_pres_tipo CHECK (
tipopres IN (‘PERS’, ‘CASA’, ‘NOVALIDO’) DISABLE,
…);
A continuación se insertan datos en la tabla, y después se activa la restricción utilizando:
ALTER TABLE prestamos ENABLE CONSTRAINT ck_pres_tipo

Después se depura la información actualizando los datos de la tabla de la siguiente

manera:
UPDATE prestamos SET tipopres=’NOVALIDO’

WHERE prestamos.ROWID IN (SELECT row_id FROM exceptions
WHERE constraints=’CK_PRES_TIPO’;
BORRAR RESTRICCIONES
►►─── ALTER TABLE ─┬─────────────┬───── tabla ─── DROP ───────►
└─ esquema. ──┘
┌─── , ─────────┐
►───────┬─── UNIQUE (─▼ columna ──) ──┴──────┬────────────────►◄
├─── PRIMARY KEY ───────────────────┤
└─── CONSTRAINT nombre_restricción ──┘
►───────┬─────────────┬───────────────────────────────────────►◄
└── CASCADE ──┘
Véase el siguiente ejemplo:
ALTER TABLE prestamos DROP CONSTRAINT ca_pres_aprobadopor;

ALTER TABLE prestamos DROP PRIMARY KEY CASCADE;
La utilización de la opción CASCADE al borrar una restricción, permite borrar dicha

restricción y además elimina todas las claves ajenas que apuntaran a la clave.
BORRAR COLUMNAS
►►─── ALTER TABLE ─┬─────────────┬───── tabla ─── DROP COLUMN ───────►
└─ esquema. ──┘
Borra una columna de una tabla. La columna no puede contener CONSTRAINT PRIMARY
KEY o FOREIGN KEY.
ALTER TABLE prestamos DROP COLUMN sal;

Para borrar varias columnas la sintaxis es:
ALTER TABLE emp DROP (hire_date,job);
EL COMANDO ALTER SEQUENCE

El comando ALTER SEQUENCE permite modificar las características y el comportamiento
de una secuencia. Se puede modificar:
• El incremento del número secuencial.
• Establecer los valores máximos y mínimos.
La secuencia debe pertenecer al usuario o bien este debe poseer el privilegio ALTER
sobre la secuencia. La sintaxis es muy parecida a la de creación:
ALTER SEQUENCE [esquema.]Nombre_de_secuencia

INCREMENT BY entero
MAXVALUE entero
NOMAXVALUE entero
MINVALUE entero
NOMINVALUE
CYCLE
NOCYCLE;
El significado de cada uno de los valores está definido en el comando CREATE

SEQUENCE.
DROP TABLE
Permite borrar una tabla. La sintaxis es la siguiente:
►───── DROP TABLE ──┬────────────────┬───── tabla ──────────►
│ │
└── esquema. ────┘
►────────┬───────────────────────────┬──────────────────────►◄
│ │
└─── CASCADE CONSTRAINTS ───┘
Mediante el siguiente ejemplo, es posible eliminar la tabla PRODUCTOS con todas sus
filas y las claves ajenas que apunten a cualquier columna de PRODUCTOS.
DROP TABLE productos CASCADE CONSTRAINTS;
DROP INDEX
Se puede eliminar un índice de una tabla utilizando el siguiente comando:
DROP INDEX nombre_indice;
A partir de este momento la columna en cuestión ya NO esta indexada. En el comando

DROP INDEX es indiferente que el índice sea único o no.
La información acerca de los índices está almacenada en el diccionario en las tablas
USER_INDEXES y USER_IND_COLUMNS
Para borrar un índice se debe ser el propietario de la tabla en la que están los índices o
tener un privilegio llamado DROP ANY INDEX.
DROP VIEW
Se puede eliminar un índice de una tabla utilizando el siguiente comando:
DROP VIEW nombre_vista;
DROP SYNONYM
Se puede borrar un sinónimo sobre una tabla, procedimiento, vista, etc. utilizando el
siguiente comando.
DROP [PUBLIC] SYNONYM nombre_sinónimo;
Con la utilización de este comando no se borra el objeto, sino solamente el alias

permanente del objeto.
La información referente a sinónimos se encuentra en las siguientes tablas:
USER_SYNONYMS y ALL_SYNONYMS
Para borrar un sinónimo basta con ser el propietario, con haberlo creado. En el caso de
que el sinónimo que se desea borrar sea público, es necesario tener el privilegio DROP
PUBLIC SYNONYM.
DROP SEQUENCE
El comando DROP SEQUENCE sirve para eliminar una secuencia de la BD. El comando a
utilizar es:
DROP SEQUENCE [Esquema.]Nombre_de_Secuencia
Suele ser el método utilizado para resetear una secuencia. Se borra y luego se vuelve a
crear con los valores deseados. Véase el siguiente ejemplo:
DROP SEQUENCE seq1;
RENAME
El comando RENAME cambia el nombre de un objeto (tabla, procedimiento, vista, etc.)
por otro de forma permanente, de la siguiente forma:
RENAME nombre_antiguo_objeto TO nombre_nuevo_objeto;
La información sobre los objetos de un usuario se encuentra en el diccionario en la vista

USER_OBJECTS
Para renombrar un objeto se debe ser propietario del mismo.
EL COMANDO TRUNCATE
El comando TRUNCATE borra filas de una tabla o índice sin eliminar la estructura del
objeto. Es similar a DELETE, pero no hay posibilidad de deshacer la transacción
(ROLLBACK), ni de hacer un borrado restrictivo (cláusula WHERE).
TRUNCATE TABLE nombre_tabla

[DROP STORAGE] [REUSE STORAGE]
• Para truncar un objeto, se debe ser propietario del mismo o tener el privilegio
DELETE ANY TABLE.
• La opción DROP STORAGE libera el espacio que el objeto ha tomado a la base de
datos, opción por defecto.
• La opción REUSE STORAGE mantiene reservado el espacio previamente adquirido
para dicho objeto.
• Al truncar una tabla se truncan de forma implícita los índices de dicha tabla
A
ANEXO A. El interfaz de usuario SQL*PLUS

TABLA DE CONTENIDOS
Introducción .......................................................................................................................1
El Editor de SQL*PLUS .....................................................................................................2
COMANDOS DE EDICION ................................................................................................... 2
El Comando SPOOL ............................................................................................................. 4
El Comando SAVE ................................................................................................................ 4
El Comando START .............................................................................................................. 4
El Comando GET .................................................................................................................. 5
El Comando EDIT .................................................................................................................. 5
El Comando DESCRIBE ....................................................................................................... 5
El Comando HOST ................................................................................................................ 5
Parámetros de Sustitución ............................................................................................... 6
Mejoras en SQL*Plus en Oracle 10g ................................................................................ 7
Mejoras en el comando DESCRIBE ...................................................................................... 7
Mejoras en el comando SPOOL ............................................................................................ 7
Configuración de Sesión ....................................................................................................... 7
Nuevas variables DEFINE ..................................................................................................... 8
Variables de Sustitución en PROMPT .................................................................................. 9
Compatibilidad SQL*Plus ...................................................................................................... 9
ANEXO A. El interfaz de usuario SQL*PLUS A-1
INTRODUCCIÓN
• SQL*Plus es una de las herramientas desde las que se ejecutan comandos SQL.
• Desde ciertas herramientas, solo están permitidos los comandos DML
(Manipulación), en Plus, en cambio también se permiten como hemos visto,
comandos DDL (definición).
• Desde SQL*PLUS se permite:
 Trabajar con SQL.
 Disponer de ayuda para comandos. Por ejemplo HELP SELECT.
 Los comandos se ejecutan de forma inmediata, o bien, pueden ser
almacenados en un buffer o en un fichero del S.O. y ser ejecutados a
posteriori.
 También se considera a PLUS una herramienta para generar informes sencillos
y tabulares. Permite realización de cálculos y de rupturas.
 Utilizar el editor propio de la herramienta (que es un editor de línea), o
trabajar desde PLUS con el editor del sistema operativo.
• Para entrar en la herramienta SQL*PLUS ya hemos visto antes que hay que
introducir el siguiente comando desde el indicador de Sistema operativo (en
UNIX):
$ sqlplus [usuario/password]
• Si no indicamos el usuario/password en la línea de comandos, la propia

herramienta lo preguntará.
$ sqlplus
Enter user-name:
Enter password:
A-2 ANEXO A. El interfaz de usuario SQL*PLUS
EL EDITOR DE SQL*PLUS
• SQL*Plus dispone de editor de líneas. Este editor permite modificar, examinar, o
reejecutar un comando SQL, sin tener que reescribirlo:
• Los comandos SQL*Plus deben introducirse después del prompt "SQL>" y SIN
punto y coma al final.
COMANDOS DE EDICION
Operador Reducido Propósito

APPEND A texto Añadir texto al final de una línea
CHANGE C/texto/ Elimina el texto de la línea.
CHANGE C/antiguo/nuevo Cambia el texto "antiguo" por el

"nuevo" en la línea indicada
CLEAR BUFFER CL BUFF Borra todas las líneas del buffer.
DEL (ninguna) Si primero me posiciono en una línea

con L4 y luego indico. DEL, sólo borra
la línea sobre la que me he
posicionado
INPUT I Añade una línea a partir del número

de línea en que me encuentro.
LIST L Muestra todas las líneas del buffer
LIST n Ln Sólo mostrará la línea "n"
LIST n m Lnm Si se indica L "n" "m", muestra las

líneas comprendidas entre ambos
números n y m inclusive.
RUN R Reejecuta la sentencia actual

Ejemplos:
• Visualizar la línea uno del buffer:
SQL> list 1
1* SELECT dptno, dname
• Cambiar dptno por deptno.
SQL> C/dptno/deptno
• Reejecutar el comando
SQL> RUN
1 SELECT deptno, dname
2 FROM DEPT
3* WHERE deptno=10
DEPTNO DNAME LOC

------ ------------- -------------------
10 ACCOUNTING NEW YORK
• Añadir una línea al final:
SQL> LIST 3
3* WHERE deptno=10
SQL> I
4* order by deptno (por ejemplo)
SQL> LIST
1 SELECT deptno, dname
2 FROM DEPT
3 WHERE deptno=10
4* order by deptno
• Añadir "desc" al final de la línea 4
SQL> L 4
4* order by deptno
SQL> AP desc
4* order by deptno des
EL COMANDO SPOOL
• El comando SPOOL se utiliza para almacenar el RESULTADO de la ejecución de
una select en un fichero:
SQL> SPOOL nombre_fichero
SQL> run
SQL> SPOOL OFF;
• Esto genera un fichero con una extensión por defecto .lst en la que esta el
resultado de la select ejecutada.
• Enviar a la impresora:
SQL> SPOOL on
SQL> run
SQL> SPOOL Out;
EL COMANDO SAVE
El comando SAVE guarda en un fichero el CONTENIDO de la sentencia SQL (solo una)
actualmente en el buffer:
SQL> SELECT * FROM dept

SQL> Save departamentos
Esto crea un fichero de sistema operativo llamado departamentos.sql con la select escrita
anteriormente.
EL COMANDO START
Ejecuta el fichero de sistema operativo que se indique:
SQL> start departamentos

SQL> select * from dept;
DEPTNO DNAME LOC

------ ------------- -------------------
20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON
Si el fichero tiene una extensión distinta a "sql" hay que indicarlo.

El comando START me permite ejecutar un fichero de comandos creado previamente y
que contenga más de una sentencia SQL.
EL COMANDO GET
• El comando GET, lleva al buffer SQL el fichero indicado, por ejemplo, para
modificarlo. Si la extensión del nombre del fichero a editar no es SQL hay que
indicar el nombre completo.
SQL> get departamentos[.extension]
SQL> select * from dept;
SQL> i
2* order by dname
SQL> SAVE departamentos [REPLACE]
• La opción REPLACE del comando SAVE reemplaza el fichero antiguo por el nuevo.
EL COMANDO EDIT
• Llama al editor activo del sistema operativo. Se puede elegir el editor deseado
utilizando:
SQL> define_editor= vi
• Esto implica que cuando el usuario ejecute:

SQL> ed
Se invoca el editor "vi" del sistema operativo.

• Si después de "ed" no se indica un nombre de fichero se creará un fichero
temporal llamado "afiedt.buf". Si después de "ed" se le especifica un nombre,
genera en el sistema operativo un fichero con ese nombre y una extensión .sql.
EL COMANDO DESCRIBE
• El comando DESCRIBE o DESC muestra la estructura de una tabla:
SQL> DESC dept
Name Null Type

------------------- --------- --------------
DEPTNO NOT NULL NUMBER(2)
DNAME VARCHAR2(14)
LOC VARCHAR2(13)
EL COMANDO HOST
• El comando HOST permite ejecutar un comando de sistema operativo sin salir de
la sesión de SQL*Plus. En algunos sistemas operativos su equivalente es el signo
de cerrar admiración (UNIX), y en otros el símbolo del dólar (NT). Veamos un
ejemplo a continuación utilizando las tres posibilidades.
SQL> HOST ls -l
SQL> ! ls -l
SQL> $ DIR /s
• Si se ejecuta solo HOST, se sale temporalmente al sistema operativo. Para

regresar a SQL*Plus, basta utilizar el comando EXIT que nos devuelve a la sesión
de base de datos.
PARÁMETROS DE SUSTITUCIÓN
• Se pueden incluir variables de sustitución en un programa en SQL*Plus:
Por ejemplo:

2 WHERE deptno = &nodepartamento;
Enter value for nodepartamento: 10
DEPTNO DNAME LOC

------ ------------- -------------------
• Si salvamos el fichero, luego podemos ejecutarlo pasando el valor de la variable

que el programa espera, en el momento de invocarlo:
SQL> save departamentos

SQL> start departamentos 10
• Se puede guardar, utilizando un doble ampersand "&&" el contenido de una

variable durante la sesión para utilizarse en otra sentencia SQL. Por ejemplo
2 WHERE deptno = &&nodepartamento;
Enter value for nodepartamento: 10
DEPTNO DNAME LOC

------ ------------- -------------------
SQL> SELECT * FROM EMP

2 WHERE deptno = &nodepartamento;
• En esta ocasión no pregunta por el valor de la variable, porque se mantiene al

haberla definido con doble ampersand.
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO
----- ------------- ---------- ---- --------- ---- ---- ------
7782 CLARK MANAGER 7839 09-JUN-81 2450 10
7739 KING PRESIDENT 17-NOV-81 5000 10
7934 MILLER CLERK 7782 23-JAN-82 1300 10
MEJORAS EN SQL*PLUS EN ORACLE 10G
MEJORAS EN EL COMANDO DESCRIBE

El comando SQL* Plus DESCRIBE se ha mejorado, y ahora puede describir reglas,
conjuntos de reglas y contextos de evaluación de reglas. Esto hace mucho más fácil
mostrar las especificaciones de reglas comparado con las consultas a las vistas del
diccionario USER_RULES o USER_RULE_SET_RULES.
Las reglas, conjuntos de reglas y contextos de evaluación de reglas se adhieren a una
topología específica. Un conjunto de reglas es un grupo de reglas relacionadas agrupadas
conjuntamente, y una regla puede ser parte de uno o varios conjuntos de reglas.
Debido a ello, el objeto regla descrito puede ser de nivel superior o no. Si es un objeto de
nivel superior, como un conjunto de reglas, debe contener la lista de reglas y un contexto
de evaluación.
El comando DESCRIBE podrá mostrar los datos de detalle mediante técnicas drill-down.
La sintaxis permanece invariable:
DESC[RIBE] {[esquema.]objeto[@connect]}
MEJORAS EN EL COMANDO SPOOL

El comando SPOOL ha sido mejorado, y permite añadir a un fichero, o reemplazar un
fichero existente. En versiones anteriores solo era posible utilizar SPOOL para crear (y
reemplazar) un fichero. La opción por defecto es REPLACE. La nueva sintaxis es:
SPOOL {file_name[.ext] [CRE[ATE]] | [REP[LACE]] | [APP[END]] | OFF | OUT}
Es posible generar un fichero HTML válido utilizando uno o varios comandos SPOOL
APPEND, construyendo manualmente las cabeceras y pies de página.
SPOOL fichero.htm
PROMPT <HTML><BODY>
SET MARKUP HTML ON
SELECT * FROM departments;
SET MARKUP HTML ENTMAP OFF
PROMPT </BODY></HTML>
SPOOL OFF
CONFIGURACIÓN DE SESIÓN
Es posible utilizar ficheros de perfiles para controlar el entorno SQL*Plus:
• El fichero de sistema GLOGIN.SQL permite definir un entorno común a todos los
usuarios de una base de datos particular.
• El fichero de usuario LOGIN.SQL permite personalizar una sesión específica.
En Oracle 10g, el fichero de perfil de sistema se ejecuta tras cada conexión satisfactoria,
ya sea mediante SQLPLUS o mediante el comando CONNECT. El fichero de usuario se
ejecuta tras el fichero de sistema.
El fichero de perfil del sistema contiene fundamentalmente asignaciones de variables de
entorno, mientras que el fichero de configuración de usuario puede contener comandos
SQL*Plus, comandos SQL o incluso bloques PL/SQL.
Por defecto, el fichero de perfil de sistema está localizado en el directorio

$ORACLE_HOME\sqlplus\admin. SQL*Plus busca el fichero de perfil de usuario en el
directorio actual, y si no en algún directorio de la variable de entorno SQLPATH.
Es posible utilizar la opción SQLPLUSCOMPATIBILITY para forzar compatibilidad hacia
atrás. Si toma un valor menor que 10, los ficheros glogin.sql y login.sql no se leerán tras
los comandos CONNECT sucesivos.
NUEVAS VARIABLES DEFINE

El comando DEFINE incorpora tres nuevas variables _DATE, _PRIVILEGE y _USER. Estas
tres nuevas variables tienen valores predefinidos. Adicionalmente _DATE puede tomar
como valor una cadena de texto definida por el usuario.
• _DATE – es una variable dinámica y muestra la fecha actual.
El formato de fecha se especifica en NLS_DATE_FORMAT. Es posible establecer un
valor diferente para _DATE mediante un comando DEFINE.
SQL> SET SQLPROMPT _DATE>

09/03/05>DEFINE _DATE='01/01/2009'
01/01/2009>
Es posible reactivar el comportamiento dinámico por defecto mediante:
01/01/2004>DEFINE _DATE=''
19/12/2008>
• _PRIVILEGE – indica el nivel de privilegio de la conexión actual mediante los

valores AS SYSDBA, AS SYSOPER o mediante una cadena vacía para conexiones
normales, o cuando no hay conexión.
SQL>conn / as sysdba
Connected.
SQL>SET SQLPROMPT _PRIVILEGE>
AS SYSDBA>
• _USER – contiene el nombre de usuario de la sesión actual.

SQL>CONN scott/tiger
Connected.
SQL>SET SQLPROMPT _USER>
SCOTT>
Pueden ser consultadas y modificadas al igual que cualquier otra variable DEFINE, y
pueden utilizarse en TTITLE, como variables de sustitución ‘&’ o como prompt de línea de
comandos SQL*Plus. Pueden utilizarse, por ejemplo, para modificar el SQLPROMPT en los
ficheros de inicialización GLOGIN.SQL y LOGIN.SQL.
VARIABLES DE SUSTITUCIÓN EN PROMPT

Es posible utilizar variables en el prompt SQL*Plus, permitiendo la sustitución de valores
de las variables en tiempo de ejecución. Es posible utilizar las variables predefinidas
_USER, _DATE y _PRIVILEGE así como cualquier otra variable definida.
Dichas variables no tienen porqué venir precedidas por un ampersand &, y actúan como
cualquier otra variable DEFINE, pudiendo ser consultadas y modificadas igualmente.
• No es necesario prefijarlas con &
• Pueden ser consultadas y modificadas como otras variables DEFINE.
Algunos ejemplos de variables de sustitución pueden ser:
• Predefinidas
SQL>SET SQLPROMPT '_USER _DATE>'
SCOTT 09/03/05>ALTER SESSION SET NLS_DATE_FORMAT = 'HH24:MI:SS';
Session altered.
SCOTT 16:24:44>
• No Predefinidas
SQL>DEFINE con=PEDRO
SQL>SET SQLPROMPT ‘con>’
PEDRO>
COMPATIBILIDAD SQL*PLUS
SQL*Plus tiene una nueva opción de línea de comandos, llamada COMPATIBILITY. Esta
opción nueva permite establecer la variable de sistema SQLPLUSCOMPATIBILITY a una
versión de SQL*Plus especificada a continuación, mediante la sintaxis:
SQLPLUS [-C[OMPATIBILITY]] {X.Y[.Z]}
La opción de línea de comandos permite establecer la variable de sistema antes de

ejecutar los ficheros de configuración de sistema o de usuario.
También es posible especificar el valor mediante el comando SQL*Plus:
SET SQLPLUSCOMPATIBILITY {X.Y.[Z]}
El ejemplo siguiente muestra cómo se evalúan las variables de sustitución en función del
valor de la variable de sistema SQLPLUSCOMPATIBILITY.
SQL>SET SQLPLUSCOMPATIBILITY 9.2.0

SQL>SET SQLPROMPT '_USER _DATE>'
_USER _DATE>SET SQLPLUSCOMPATIBILITY 10.1
SCOTT 16:32:28>
B
ANEXO B. El interfaz de usuario
iSQL*PLUS
TABLA DE CONTENIDOS
Utlización de iSQL*Plus ....................................................................................................1

Introducción a iSQL*Plus...................................................................................................... 1
Espacio de Trabajo iSQL*Plus .............................................................................................. 2
Visualización de Resultados.................................................................................................. 3
Configuración del Interfaz...................................................................................................... 4
Configuración de Sistema ..................................................................................................... 5
Pantalla de Formato de Salida ......................................................................................... 5
Pantalla de Ejecución de Scripts ...................................................................................... 5
Pantalla de Administración de Base de Datos ................................................................. 6
Cambio de Contraseñas................................................................................................... 6
Cambios en Comandos ......................................................................................................... 7
ANEXO B. El interfaz de usuario iSQL*PLUS B-1
UTLIZACIÓN DE ISQL*PLUS
INTRODUCCIÓN A ISQL*PLUS
Oracle proporciona desde la versión Oracle9i un nuevo entorno de trabajo llamado

iSQL*Plus, muy similar al SQL*Plus, pero accesible desde un navegador web.
iSQL* Plus es una implementación de SQL* Plus basada en una arquitectura de tres
capas (cliente, aplicación y servidor).
• La capa servidor es el servidor de Bases de Datos.
• La capa aplicación incluye la aplicación iSQL* Plus Server.
Isql*Plus Server permite la autentificación y comunicación entre la interfaz de
usuario de iSQL*Plus y el servidor de Base de Datos.
El servidor iSQL*Plus Server se instala como parte de Oracle HTTP Server, que se
incluye con el software de instalación de Oracle9i.
• La capa cliente es un thin client, que incluye un navegador de internet.
La interfaz de usuario de iSQL*Plus se ejecuta en un explorador web conectado a
internet o a la red local corporativa. Basta con conocer la URL de Oracle HTTP
Server para acceder a Oracle10g o cualquier base de datos Oracle. No se
requieren instalaciones ni configuraciones para la interfaz de usuario de
iSQL*Plus, simplemente un explorador web.
Las tres capas pueden estar en la misma máquina o en máquinas diferentes.
Existen dos modos de conectarse a iSQL Plus:
• Como usuario estándar.
http://host.dominio:puerto/isqlplus [?UserOpts]
Donde UserOpts tiene la sintaxis UserLogin | Script | UserLogin & Script
UserLogin tiene la sintaxis userid=user [/pwd] [@cadena_conexión]

Script tiene la sintaxis script= text [&type={url|text}]
[&actino={execute|load}]
[&variable=valor...]
• Como usuario con privilegios (SYSOPER o SYSDBA).

http://host.dominio:puerto/isqlplusdba [DBAopts]
Donde DBAOpts tiene la sintaxis DBALogin | Script | DBALogin & Script
DBALogin tiene la sintaxis userid={user[/pwd][@cadena_conexión]|/}AS{SYSDBA|SYSOPER}
Script tiene la sintaxis script= text [&type={url|text}] [&action={execute|load}]

[&variable=valor...]
B-2 ANEXO B. El interfaz de usuario iSQL*PLUS
Cuando accedemos a la URL, debemos introducir es nuestros datos de conexión:
Ilustración 1 - Pantalla de Conexión

Oracle Database 10g proporciona mejoras en cuanto al acceso y forma de trabajo de
iSQL*Plus y de SQL*Plus con respecto a versiones anteriores.
ESPACIO DE TRABAJO ISQL*PLUS

La ventana de Espacio de Trabajo (Workspace), renombrada de la anterior Ventana de
Trabajo (Work Screen), es el área principal de trabajo en iSQL*Plus. Consta de las
ventanas Workspace, History y Load Scripts. La ventana Workspace muestra la
información de conexión. Desde esta ventana es posible acceder a las preferencias,
introducir y ejecutar scripts, ver los resultados, obtener ayuda, etc.
Ilustración 2 - Ventana WorkScreen

El área de trabajo contiene un área de entrada y un área de salida. El área de entrada
permite introducir el código a ejecutar y guardarlo como un script, o cargar un script
desde un fichero o URL.
El botón Clear a nivel de página limpia tanto el área de entrada como el área de salida, y
también cancela la ejecución de un script. El botón Cancel cancela la ejecución de un
script sin limpiar los contenidos del área de entrada.
Por defecto, la salida se muestra en el área de salida debajo del script. Es posible
guardar la salida a un fichero HTML, o generar una salida de impresión en la misma
ventana del navegador o en una nueva ventana.
El botón Preferences permite modificar las propiedades del interfaz iSQL*Plus, las
propiedades del sistema y la contraseña del usuario.
VISUALIZACIÓN DE RESULTADOS
Para proporcionar más control sobre la cantidad de datos mostrados en el área de salida
del navegador, iSQL*Plus Oracle Database 10g introduce la nueva funcionalidad Conjunto
siguiente de Resultados. Es posible especificar el número de líneas de datos a mostrar
mediante el comando SET PAGESIZE.
Tras mostrar el conjunto inicial de resultados, es posible utilizar el botón

para mostrar el siguiente conjunto de datos. Por defecto, el tamaño de página está
definido a 24, y la preferencia SET PAUSE está a ON.
Es posible modificar las propiedades mediante el botón Preferencias , o modificando el

fichero glogin.sql.
Ilustración 3 - Preferencias de Salida

Es posible controlar la cantidad de salida de comandos sucesivos mediante la inserción de
comandos PAUSE en diferentes puntos. El comando PAUSE activa la utilidad Conjunto
Siguiente de Resultados. Cualquier salida antes del comando PAUSE es enviada al
navegador. Mediante el botón el usuario decide cuando ejecutar las
consultas sucesivas y ver mas resultados hasta el comando PAUSE siguiente.
La pantalla de historial contiene una lista de las sentencias y scripts ejecutados durante
la sesión. El historial no se almacena a lo largo de múltiples sesiones, y solo está
disponible para la sesión actual. Si el usuario se desconecta de iSQL*Plus o la sesión
expira, el historial se pierde.
Es posible cargar scripts desde el historial al espacio de trabajo. También es posible
borrar scripts del historial. Si el usuario selecciona múltiples comandos de la lista de
históricos, los comandos se cargan al espacio de trabajo en el orden en el que se
muestran en el historial.
Ilustración 4 - Ventana de Históricos

Al borrar un comando del historial, mediante el botón , el historial se actualiza. Un
mensaje confirmará la eliminación del comando de la lista de históricos.
CONFIGURACIÓN DEL INTERFAZ

La pantalla de configuración del interfaz permite controlar la apariencia del interfaz. Es
posible acceder a las propiedades mediante el botón de Preferencias .
Ilustración 5 - Pantalla de Configuración del Interfaz

Es posible establecer donde se va a mostrar la salida: en una nueva ventana del
navegador, en la misma ventana o en un fichero HTML.
También es posible modificar el tamaño de cada página de salida, modificar el tamaño
del área de comandos, el número de comandos almacenados en la ventana de Historial,
o establecer si los comandos de los scripts se muestran al ejecutar los scripts.
CONFIGURACIÓN DE SISTEMA
La pantalla de Configuración de Sistema reemplaza a la pantalla de Variables de Sistema
de Isql*PLUS 9.2.0. Contiene subcategorías para configurar formatos de salida, ejecución
de scripts y administración de la base de datos.
PANTALLA DE FORMATO DE SALIDA

La pantalla de Formato de Salida muestra las opciones de configuración que afectan a la
forma en que se muestran los datos.
Ilustración 6 - Pantalla de Formato de Salida
PANTALLA DE EJECUCIÓN DE SCRIPTS

Esta pantalla muestra las opciones de configuración que definen cómo se ejecutarán los
scripts. Incluyen ajustes para definir la validación automática de SQL, concatenación,
recuperación de datos, hints de optimización, etc.
Ilustración 7 - Pantalla de Ejecución de Scripts

PANTALLA DE ADMINISTRACIÓN DE BASE DE DATOS

Esta pantalla muestra las opciones de configuración que afectan a la administración de la
base de datos. Incluye opciones para la instancia, rutas de acceso para ficheros de
archivado offline y recuperación automática.
Ilustración 8 - Pantalla de Administración de Base de Datos
CAMBIO DE CONTRASEÑAS
Esta pantalla permite gestionar las contraseñas del usuario conectado. Los usuarios con
privilegios podrán cambiar también las contraseñas de otros usuarios.
Ilustración 9 - Pantalla de Cambio de Contraseñas

CAMBIOS EN COMANDOS
El comando ACCEPT en iSQL*Plus muestra el promp por defecto “Enter value for
<variable>”, mientras que en SQL*Plus es una cadena vacía. Es posible utilizar la opción
PROMPT para personalizar un mensaje. iSQL*Plus ignora la opción NOPROMPT.
El comando CONNECT no necesita el identificador completo usuario/pwd. Si se especifica
usuario y contraseña, el campo password no muestra el contenido.
El comando PASSWORD se comporta como si fuese en modo comando, o sea mostrando
tres campos individuales: usuario, contraseña y confirmación de contraseña. Puede
utilizar la pantalla Change Password para modificar la contraseña en modo gráfico.
El comando RECOVER ya no requiere que la opción SET AUTORECOVERY está definida a
ON. iSQL*Plus solicita los logs de archivado offline y muestra las opciones Continue o
Cancel para aplicar los cambios de dichos logs.
Aunque iSQL*Plus soporta el comando RECOVER, no es recomendable su uso en este
entorno, debido a que el navegador podría mostrar mensajes de timout mientras la base
de datos está procesando un archivo de redo log offline. Un dba debe considerar,
igualmente, cuestiones de seguridad antes de acceder a la base de datos mediante
iSQL*Plus.
iSQL*Plus muestra un mensaje por cada variable de sustitución según las encuentra
dentro del script. Este es un cambio considerable frente a versiones anteriores.
Varios comandos no están disponibles, o no son útiles en iSQL*Plus cuando se ejecutan
en un script. Por ejemplo, los comandos de edición de buffer como CHANGE. Los scripts
que necesiten ser ejecutados en ambos entornos SQL*Plus e iSQL* Plus deberían utilizar
comandos disponibles en ambos entornos.
C
ANEXO C. Nuevas Funcionalidades
Oracle10g.
TABLA DE CONTENIDOS
Introducción .......................................................................................................................1
Nuevos Tipos de Datos .....................................................................................................1
Operadores de Comparación ................................................................................................ 3
Nuevas Funciones ................................................................................................................. 4
Restricciones en Columnas de Coma Flotante ..................................................................... 4
Expresiones Regulares .....................................................................................................5
Mecanismo de Búsqueda ...................................................................................................... 5
Meta Caracteres .................................................................................................................... 6
Funciones .............................................................................................................................. 7
Expresiones Regulares en DDL ............................................................................................ 8
Restricciones .................................................................................................................... 8
Índices .............................................................................................................................. 8
Vistas ................................................................................................................................ 9
Nuevos Métodos de Ordenación ...................................................................................... 9
Parámetros de Configuración ................................................................................................ 9
Impacto en Sentencias SQL ................................................................................................ 10
Ejemplo NLS_SORT............................................................................................................ 10
Función NLSSORT .............................................................................................................. 11
Cálculos Inter-Filas en SQL ............................................................................................ 11
Beneficios ............................................................................................................................ 12
Cláusula SPREADSHEET ................................................................................................... 12
Terminología ........................................................................................................................ 12
Referencias.......................................................................................................................... 14
Referencias a Celdas ..................................................................................................... 14
Referencias a Rangos .................................................................................................... 14
Función CURRENTV() ........................................................................................................ 15
Bucles Cualificados Incrementales ..................................................................................... 16
Bucles de Subconsulta Cualificados ................................................................................... 17
Valores Nulos y No Encontrados......................................................................................... 17
Opción UPDATE .................................................................................................................. 19
Orden de Evaluación de Reglas .......................................................................................... 20
Mejoras SQL Data WareHouse ....................................................................................... 20
Extensiones a la sentencia MERGE ................................................................................... 20
Cláusulas INSERT o UPDATE opcionales .................................................................... 21
Cláusulas UPDATE condicionales ................................................................................. 21
Condiciones ON Especiales ........................................................................................... 21
INSERT Condicionales ................................................................................................... 21
Cláusula DELETE Opcional ........................................................................................... 22
Mejoras en CONNECT BY .................................................................................................. 22
CONNECT BY ROOT .................................................................................................... 22
CONNECT BY ISLEAF .................................................................................................. 22
CONNECT BY ISCYCLE ............................................................................................... 23
ANEXO C. Nuevas Funcionalidades Oracle10g. C-1
INTRODUCCIÓN
El motor SQL de Oracle es la base subyacente de todas las aplicaciones de base de datos
Oracle. El lenguaje SQL de Oracle evoluciona continuamente para alcanzar las demandas
crecientes de las aplicaciones cada vez más complejas.
Oracle Database 10g incorpora nuevas capacidades SQL, convirtiendo a Oracle en la
mejor implementación de uno de los estándares más populares y duraderos en
informática.
A continuación se profundizará en las siguientes mejoras de SQL proporcionadas por
Oracle Database 10g:
• Los nuevos tipos de datos de coma flotante, basados en el estándar IEEE 754,
incorporados a Oracle Database 10g mejoran el rendimiento de operaciones de
coma flotante comunes en Java y XML, a la vez que reducen las necesidades de
espacio de almacenamiento.
• El soporte nativo en SQL de expresiones regulares revolucionará las búsquedas y
manipulaciones de texto dentro de la base de datos.
• Las consultas SQL pueden incluir una nueva sintaxis de cálculos analíticos
complejos sobre arrays de filas, proporcionando a SQL capacidades de cálculo
cercanas a las Hojas de Cálculo.
• Mejoras en la sentencia MERGE.
• Mejoras en nuevas cláusulas para consultas jerárquicas
NUEVOS TIPOS DE DATOS

Oracle Database 10g introduce dos nuevos tipos de datos numéricos de coma flotante.
Los tipos de datos BINARY_FLOAT y BINARY_DOUBLE almacenan datos numéricos de
coma flotante en formato IEEE 754 de 32 bits y en formato IEEE 754 de 64 bits de doble
precisión respectivamente.
En comparación con el tipo de dato Oracle NUMBER, las operaciones aritméticas con
datos numéricos de coma flotante son más rápidas con estos tipos de datos. Igualmente,
los valores con precisión significativa requerirán menos espacio de almacenamiento con
estos tipos de datos.
Las operaciones aritméticas con los tipos de datos BINARY_FLOAT y BINARY_DOUBLE se
realizan por el juego de instrucciones nativo suministrado por el proveedor de hardware.
La compatibilidad con el estándar IEEE 754 asegura resultados comunes a lo largo de
todas las plataformas soportadas.
Adicionalmente, los nuevos tipos de datos de coma flotante ofrecen nuevas posibilidades:
• Creación de tablas con columnas de tipo BINARY_FLOAT y BINARY_DOUBLE.
• Inclusión de columnas BINARY_FLOAT y BINARY_DOUBLE en cláusulas SELECT.
• Creación de índices sobre columnas BINARY_FLOAT y BINARY_DOUBLE.
• Las operaciones de agrupamiento están soportadas para columnas
BINARY_FLOAT y BINARY_DOUBLE.
• Las columnas BINARY_FLOAT y BINARY_DOUBLE pueden ser incluidas en
cláusulas order by y group by.
C-2 ANEXO C. Nuevas Funcionalidades Oracle10g.
• El almacenamiento de los datos BINARY_FLOAT y BINARY_DOUBLE es

independiente de la plataforma.
Hasta ahora, el tipo de datos Oracle Number era el único tipo de dato soportado por
Oracle, y todas las operaciones aritméticas se realizaban con dicho tipo de datos. Los
beneficios de Oracle Number incluyen:
• Portabilidad, pues está implementado mediante software.
• Representación decimal. La precisión no se pierde al convertir cadenas de texto
en valores numéricos, y el redondeo se realiza en valores decimales. Muchas
aplicaciones requerían este comportamiento.
• Limitando el tipo de datos en la base de datos, muchos de los operadores
aritméticos y funciones matemáticas no están sobrecargadas.
Sin embargo, Java y XML cobran mayor importancia en las aplicaciones de base de datos
hoy en día. Estos lenguajes soportan el estándar IEEE 754 para aritmética binaria de
punto flotante.
Aún más, muchas aplicaciones de base de datos requieren cálculos intensivos de coma
flotante (OLAP, Data Mining, etc.), de manera que todas ellas se beneficiarán del
aumento de rendimiento, reducción del espacio de almacenamiento y mayor
funcionalidad de dichos tipos de datos.
BINARY_FLOAT y BINARY_DOUBLE no sustituyen al tipo de dato Oracle NUMBER, sino
que constituyen una alternativa que proporciona los siguientes beneficios:
• BINARY_FLOAT y BINARY_DOUBLE coinciden con los tipos de datos utilizados por

los clientes Java y XML de una base de datos. Ambos soportan tipos de datos
equivalentes a los tipos de datos IEEE 754.
Hasta ahora, los datos numéricos eran almacenados como Oracle Number, y la
conversión desde y hacia BINARY_FLOAT y BINARY_DOUBLE podía perder
precisión o provocar un error. Esto es debido a que Oracle Number utiliza una
representación en base 10, mientras que BINARY_FLOAT y BINARY_DOUBLE
utilizan base 2.
• Los cálculos aritméticos son entre 5 y 10 veces más rápidos para BINARY_FLOAT
y BINARY_DOUBLE que para Oracle Number.
• Los datos BINARY_FLOAT utilizan 5 bytes, mientras que BINARY_DOUBLE utiliza 9
bytes, incluyendo el byte de longitud de campo. Oracle Number utiliza de 1 a 22
bytes de longitud.
• IEEE 754 proporciona toda la funcionalidad necesaria para escribir algoritmos
numéricos. Muchas de esas características no son proporcionadas por Oracle
Number.
• Oracle NUMBER está implementado por software, lo que hace que las operaciones
con dicho tipo de datos sean menos eficientes que las operaciones con valores
nativos de coma flotante, implementados por hardware y soportados por la
mayoría de los conjuntos de instrucciones actuales.
• Las funciones aritméticas y matemáticas que utilizan los tipos de datos
BINARY_FLOAT y BINARY_DOUBLE son más rápidas y utilizan menos espacio en
disco.
Tanto SQL como PL/SQL ofrecen soporte completo para ambos tipos de datos.
BINARY_FLOAT y BINARY_DOUBLE pueden ser utilizados en cualquier contexto donde
sea posible utilizar un tipo de dato escalar.
Véase un ejemplo de SQL:
SQL> CREATE TABLE mitabla (f BINARY_FLOAT, d BINARY_DOUBLE);

Table created.
SQL> INSERT INTO mitabla VALUES (2.0f, 2.0d)
1 row created.
SQL> INSERT INTO mitabla VALUES (1.5f/0.5f, 1.5d/0.5d);
1 row created.
SQL> INSERT INTO mitabla VALUES (1.0f/0.0f, 1.0d/0.0d);
1 row created.
SQL> SELECT * FROM mitabla;
F D
---------- ----------
2,0E+000 2,0E+000
3,0E+000 3,0E+000
Inf Inf
OPERADORES DE COMPARACIÓN
Los operadores de comparación son:
• Igual a / Distinto a
• Mayor que / Mayor o Igual que
• Menor que / Menor o Igual que
• Desordenado
Las comparaciones son siempre exactas, siguiendo las reglas siguientes:
• Una comparación retorna un valor TRUE, FALSE o NULL.
• Es posible comparar valores NaN.
 NaN = NaN devuelve TRUE
 NaN = 3.0f devuelve FALSE
 NaN != NaN devuelve FALSE
 NaN != 3.0f devuelve TRUE
 NaN > 3.0f devuelve TRUE
SQL> SELECT CASE
2 WHEN binary_float_NaN > 3.0f THEN 'cierto'
3 ELSE 'falso' END valor
4* FROM dual
VALOR
------
cierto
• Los valores infinitos pueden ser comparados.

• Las comparaciones ignoran el signo de 0 (-0 es igual a +0).
NUEVAS FUNCIONES
Oracle proporciona las siguientes funciones nuevas que ofrecen soporte a los nuevos
tipos de datos:
• TO_BINARY_FLOAT: Convierte un valor BINARY_DOUBLE, NUMBER, VARCHAR2 o
CHAR a BINARY_FLOAT.
• TO_BINARY_DOUBLE: Convierte un valor BINARY_FLOAT, NUMBER, VARCHAR2 o
CHAR a BINARY_DOUBLE.
• IS NAN/ IS NOT NAN: Determina si un valor es o no NaN.
• IS INFINITE/ IS NOT INFINITE: Determina si un valor es o no infinito positivo o
negativo.
• NANVL: Traduce un NaN a un valor especificado. Si el valor a traducir no es NaN,
devuelve dicho valor.
SQL> SELECT CASE
2 WHEN f IS INFINITE
3 THEN 'enorme'
4 ELSE TO_CHAR(f) END valor
5* FROM mitabla
VALOR
----------------------------------
2,0E+000
3,0E+000
enorme
RESTRICCIONES EN COLUMNAS DE COMA FLOTANTE

Oracle Database 10g permite crear seis tipos de restricciones sobre columnas numéricas
de coma flotante:
• NOT NULL.
• UNIQUE
• PRIMARY KEY
• FOREIGN KEY
• REFERENCES
• Restricciones CHECK
Véase el ejemplo siguiente:
SQL> CREATE TABLE coma_flotante1 (

2 fltnn BINARY_FLOAT CONSTRAINT flt_null NOT NULL,
3 dblnn BINARY_DOUBLE CONSTRAINT dbl_null NOT NULL,
4 fltunq BINARY_FLOAT CONSTRAINT flt_uq UNIQUE,
5 dblunq BINARY_DOUBLE CONSTRAINT dbl_uq UNIQUE,
6 fltchk BINARY_FLOAT CONSTRAINT flt_ck CHECK (fltchk IS NOT nan),
7 dblchk BINARY_DOUBLE CONSTRAINT dbl_ck CHECK (dblchk IS NOT nan),
8* fltpk BINARY_FLOAT CONSTRAINT flt_pk PRIMARY KEY)
Table created.
SQL> CREATE TABLE coma_flotante2 (

2 dblpk BINARY_DOUBLE CONSTRAINT dbl_pk PRIMARY KEY,
3 fltfrn BINARY_FLOAT CONSTRAINT flt_frn
REFERENCES coma_flotante1 (fltpk) ON DELETE CASCADE);
Table created.
EXPRESIONES REGULARES
La manipulación y búsquedas de cadenas de texto generan un gran porcentaje de la
lógica en las aplicaciones web. Las expresiones regulares son un método de describir
patrones simples o complejos de búsqueda y manipulación.
El estándar POSIX (Portable Operating System for UNIX) es un estándar IEEE que define
dos versiones diferentes de sintaxis de las expresiones regulares: Básica y Extendida. La
sintaxis extendida es un superconjunto de la sintaxis básica que ofrece mejores
funcionalidades de búsqueda al incluir operadores adicionales.
En Oracle 10g es posible utilizar el soporte de expresiones regulares tanto en SQL como
en PL/SQL. El NLSRTL (National Language Support RunTime Library) proporciona todos
los elementos lingüísticos para implementar dicho soporte.
MECANISMO DE BÚSQUEDA
La búsqueda de coincidencias comienza a principio de la cadena, en el primer carácter. Si
el carácter no coincide, el proceso comienza de nuevo con el siguiente carácter de la
cadena. Si el carácter coincide, se examina el carácter siguiente a buscar y se almacena
cualquier alternativa que pudiera haber resultado en la búsqueda. Este proceso continúa
hasta que falle la búsqueda de un carácter. Entonces, se recupera la última alternativa
almacenada en la posición donde se encontró la coincidencia.
Véase el siguiente ejemplo:
Expresión Regular: ‘a(b|c)d’

Cadena de búsqueda : ‘aabcd’
a a b c d
^ Búsqueda de ‘a’ y acierta Coincidencia
^ Búsqueda de ‘a’ y falla No coincide
^ Búsqueda de ‘b’ y falla No coincide
^ Búsqueda de ‘c’ y falla, inicializa y avanza No coincide
^ Búsqueda de ‘a’ y acierta Coincidencia
^ Búsqueda de ‘b’ y acierta. Almacena ‘c’ como alternativa Coincidencia
^ Búsqueda de ‘d’ y falla No coincide
^ Búsqueda de ‘c’ como última alternativa almacenada y No coincide
falla, inicializa y avanza
^ Búsqueda de ‘a’ y falla, inicializa y avanza No coincide
META CARACTERES
Los meta caracteres son caracteres especiales que poseen un significado especial, como
por ejemplo, caracteres comodín, caracteres repetitivos, caracteres no coincidentes o
rangos de caracteres.
La tabla siguiente muestra algunos de los meta caracteres disponibles:
Sintaxis Descripción Clasificación
. Busca cualquier carácter Punto
a? Busca ‘a’ cero o una veces Cuantificador
a* Busca ‘a’ cero o varias veces Cuantificador
a+ Busca ‘a’ una o más veces Cuantificador
a|b Busca o bien ‘a’ o bien ‘b’ Alternativa
a{m} Busca ‘a’ exactamente m veces Cuantificador
a{m,} Busca ‘a’ al menos m veces Cuantificador
a{m,n} Busca ‘a’ entre m y n veces Cuantificador
[abc] Busca o bien ‘a’ o bien ‘b’ o bien ‘c’ Corchetes
(...) Agrupa una expresión Subexpresión
\n Busca la enésima subexpresión Referencia hacia atrás
[:cc:] Busca la clase de caracteres entre corchetes Clase de Caracteres
[.ce.] Busca el elemento de colación entre corchetes Elemento de Colación
[=ec=] Busca la clase de equivalencia entre corchetes Clase de Equivalencia
Los ejemplos siguientes ilustran la utilización de meta caracteres.
• Búsqueda simple. Busca la expresión ‘abc’ en una cadena
Expresión: ‘abc’
Coincidencia: ‘abc’
No coincide: ‘def’
• Busca un carácter ‘a’ seguido de cualquier carácter, y seguido del carácter ‘c’.
Expresión: ‘a.c’
Coincidencia: ‘abc’
Coincidencia: ‘adc’
Coincidencia: ‘alc’
Coincidencia: ‘a&c’
No coincide: ‘abb’
• Busca una o más coincidencias del carácter ‘a’
Expresión: ‘a+’
Coincidencia: ‘a’
Coincidencia: ‘aa’
Coincidencia: ‘aaa’
No coincide: ‘bbb’
Es posible buscar listas de caracteres no coincidentes. Esta lista permite definir un

conjunto de caracteres para los cuales cualquier coincidencia no es válida.
• Busca cualquier carácter excepto los caracteres ‘a’, ‘b’ o ‘c’.
Expresión: ‘[^abc]’
Coincidencia: ‘abcdef’
Coincidencia: ‘ghi’
No coincide: ‘abc’
• Busca cualquier carácter que no esté entre ‘a’ y ‘f’.
Expresión: ‘[^a-f]’
Coincidencia: ‘efghi’
Coincidencia: ‘lmn’
No coincide: ‘abc’
FUNCIONES
Oracle Database 10g proporciona un conjunto de funciones que proporcionan toda la
funcionalidad de las expresiones regulares. Todas las funciones soportan tipos de datos
CHAR, VARCHAR2, CLOB, NCHAR, NVARCHAR2 y NCLOB.
Función Descripción
REGEXP_LIKE Determina qué patrón coincide. Similar
al operador LIKE.
REGEXP_SUBSTR Busca un patrón dentro de una
cadena, devolviendo una subcadena.
Similar a la función SUBSTR.
REGEXP_INSTR Busca una subcadena determinada,
devolviendo la posición donde se
encuentra dentro de una cadena.
REGEXP_REPLACE Busca un patrón y lo reemplaza por
una cadena.
•
• REGEXP_LIKE – Devuelve un valor booleano indicando si el patrón coincide con la
cadena dada o no. No proporciona detalles acerca de la coincidencia.
SELECT first_name ||' '|| last_name, salary, EXTRACT(YEAR FROM hire_date)
FROM employees
WHERE REGEXP_LIKE (TO_CHAR(hire_date, 'YYYY'), '199[8-9]$');
• REGEXP_SUBSTR – Devuelve la cadena que coincide con el patrón especificado.

SELECT first_name ||' '|| last_name FROM employees
WHERE REGEXP_SUBSTR (first_name ||' '|| last_name,
'K((ing)?|(ew)|(own)|(ies))') = 'King‘;
• REGEXP_INSTR – Devuelve la posición del carácter tanto del comienzo como del
final de la coincidencia. No es posible trabajar desde el final de la cadena.
SELECT * FROM product
WHERE REGEXP_INSTR(descrip, 'TENNIS', 1, 3) = 0;
• REGEXP_REPLACE – Reemplaza la cadena que coincide con el patrón.

SELECT first_name ||' '||last_name nombre, job_title,
REGEXP_REPLACE( LOWER(email||'@cleformacion.com'), '(.)', '\1 ') email
FROM employees NATURAL JOIN jobs
ORDER BY 2;
Mediante la función REGEXP_REPLACE es muy sencillo filtrar ciertos datos. El siguiente

ejemplo muestra cómo escribir un filtro HTML muy sencillo.
SQL> SELECT REGEXP_REPLACE(

2 '<HTML><HEAD><TITLE>Mi página Web</TITLE> </HEAD> </HTML>',
3 '<[^>]+>')
4 FROM dual;
REGEXP_REPLAC
-------------
Mi página Web
EXPRESIONES REGULARES EN DDL
RESTRICCIONES
Es posible utilizar Expresiones Regulares para filtrar los datos a introducir en una tabla
mediante el uso de restricciones. El ejemplo siguiente muestra cómo configurar una
columna de tipo VARCHAR2 para permitir únicamente caracteres alfabéticos. Esto
impedirá introducir en dicha columna cualquier signo de puntuación, números, espacios
en blanco, etc.
SQL> CREATE TABLE t1 (c1 VARCHAR2(20)

2 CHECK (REGEXP_LIKE (C1, '^[[:alpha:]]+$')))
Table created.
SQL> INSERT INTO t1 VALUES ('PedroMarco');

1 row created.
SQL> INSERT INTO t1 VALUES ('Pedro Marco');

INSERT INTO t1 VALUES ('Pedro Marco')
*ERROR at line 1:ORA-02290: check constraint (HR.SYS_C005282) violated
SQL> INSERT INTO t1 VALUES ('Pedro2');

INSERT INTO t1 VALUES ('Pedro2')
SQL> INSERT INTO t1 VALUES('Pedro_Marco');

INSERT INTO t1 VALUES('Pedro_Marco')
ÍNDICES
Suele ser habitual mejorar el rendimiento de acceso a una tabla mediante la creación de
índices sobre columnas de uso frecuente y fácilmente indexables. Las expresiones
regulares de Oracle no es fácil que hagan uso de los índices pues éstos se basan en
conocer cómo comienza la columna, y no ayudan mucho a las funciones que buscan
patrones complejos sobre la columna.
Es posible, sin embargo, hacer uso de índices basados en funciones en aquellos casos
donde se prevea utilizar la misma expresión sobre una columna en múltiples consultas. El
índice se crea en base a los resultados de la función.
SQL> CREATE INDEX t1_idx ON t1 (REGEXP_SUBSTR(c1, 'a'));

Index created.
SQL> SELECT c1 FROM t1 WHERE REGEXP_SUBSTR(c1, 'a') = 'a';

VISTAS
Las vistas son un buen mecanismo para mostrar subconjuntos de una consulta o para
formatear los datos antes de mostrarlos al usuario final. La combinación de vistas y
expresiones regulares facilita la tarea de formatear los datos.
El ejemplo siguiente modifica una dirección de correo para evitar la detección automática
de las mismas, pero manteniéndolas legibles. Una manera de hacerlo sería incluyendo un
espacio entre cada carácter. Mediante REGEXP_REPLACE y referencias hacia atrás, será
posible reemplazar cada letra por sí misma seguida de un espacio en blanco.
SQL> CREATE VIEW v1 AS SELECT employee_id, first_name||' '||last_name nombre,

2 REGEXP_REPLACE( LOWER(email||'@cleformacion.com'), '(.)', '\1 ') email
3 FROM employees;
View created.
SQL> SELECT nombre, email FROM v1 WHERE employee_id=200;

NOMBRE EMAIL
---------------- ------------------------------------------------------
Jennifer Whalen j w h a l e n @ c l e f o r m a c i o n . c o m
NUEVOS MÉTODOS DE ORDENACIÓN

En versiones anteriores, es posible utilizar funciones para hacer las sentencias SQL
insensibles a mayúsculas. Esto tiene tres inconvenientes:
• Es difícil de migrar a/ desde bases de datos de otro proveedor.
• Se produce una degradación de rendimiento al usar las funciones UPPER/ LOWER.
• Menos flexibilidad y reusabilidad de la misma sentencia SQL.
En la versión de Oracle 9i, el estándar unicode para ordenaciones multi-lingües es
utilizado a nivel de comparación. Existen tres niveles de ordenación. El nivel primario
busca diferencias entre caracteres. El nivel secundario se basa en diferencias de acentos.
El nivel terciario es para diferencias entre mayúsculas y minúsculas.
En Oracle 10g hay dos opciones de ordenación:
• Ordenación insensible a mayúsculas.
• Ordenación insensible a acentos.
PARÁMETROS DE CONFIGURACIÓN
Es posible utilizar el parámetro de sesión NLS_SORT para especificar el nombre de
ordenación lingüística. El valor por defecto se deriva del parámetro NLS_LANGUAGE. Los
valores _AI y _CI se añaden como sufijo al nombre de ordenación para indicar una
ordenación insensible a acentos o una ordenación insensible a mayúsculas.
SQL> SELECT * FROM nls_session_parameters;
PARAMETER VALUE
------------------------------ ---------------------------
NLS_LANGUAGE SPANISH
NLS_TERRITORY SPAIN
NLS_CURRENCY €
NLS_ISO_CURRENCY SPAIN
NLS_NUMERIC_CHARACTERS ,.
NLS_CALENDAR GREGORIAN
NLS_DATE_FORMAT DD/MM/RR
NLS_DATE_LANGUAGE SPANISH
NLS_SORT SPANISH
NLS_TIME_FORMAT HH24:MI:SSXFF
(…)
La sintaxis para modificar el parámetro de sesión NLS_SORT es la siguiente:
SQL> ALTER SESSION SET nls_sort='<NLS_sort_name>[_AI|_CI]';
A continuación se muestran algunos ejemplos :
SQL> ALTER SESSION SET nls_sort='JAPANESE_M'; -- Accent & Case Sensitive

SQL> ALTER SESSION SET nls_sort='FRENCH_M_AI'; -- Accent & Case Insensitive
SQL> ALTER SESSION SET nls_sort='SPANISH_CI'; -- Accent Sens. & Case Insens.
SQL> ALTER SESSION SET nls_sort='BINARY_CI'; -- Accent Sens. & Case Insens.
SQL> ALTER SESSION SET nls_sort='BINARY_AI'; -- Accent & Case Insensitive
IMPACTO EN SENTENCIAS SQL

Las siguientes cláusulas SQL se verán afectadas por los valores de NLS_SORT y
NLS_COMP establecidos a nivel de sesión:
• WHERE
• ORDER BY
• START UIT
• HAVING
• IN / NOT IN
• BETWEEN
• CASE-WHEN
EJEMPLO NLS_SORT
SQL> CREATE TABLE prueba (TEXTO VARCHAR2(100));

SQL> INSERT INTO prueba VALUES ('cordoba');
SQL> INSERT INTO prueba VALUES ('córdoba');
SQL> INSERT INTO prueba VALUES ('CORDOBA');
SQL> INSERT INTO prueba VALUES ('CÓRDOBA');
SQL> SELECT * FROM nls_session_parameters;

PARAMETER VALUE
------------------------------ -------------------------
...
NLS_SORT SPANISH
...
SQL> SELECT * FROM prueba ORDER BY texto;
TEXTO
-------------------------------------------------------------
CORDOBA
CÓRDOBA
cordoba
córdoba
SQL> ALTER SESSION SET nls_sort='SPANISH_AI';

TEXTO
-------------------------------------------------------------
cordoba
córdoba
CORDOBA
CÓRDOBA
SQL> ALTER SESSION SET nls_sort='SPANISH_CI';

TEXTO
-------------------------------------------------------------
cordoba
CORDOBA
córdoba
CÓRDOBA
FUNCIÓN NLSSORT
La función NLSSORT extiende el soporte de los nuevos métodos de ordenación a
sentencias SQL concretas. La sintaxis es la siguiente:
NLSSORT (<columna>, ‘NLS_SORT=<NLS_sort_name>[_AI|_CI]’)
La función NLSSORT puede tomar un valor del parámetro NLS_LANG o del parámetro
NLS_LANGUAGE como alternativa.
NLSSORT (<columna>, ‘NLS_LANG=<language_abbrev>’)

NLSSORT (<columna>, ‘NLS_LANGUAGE=<language_name>’)
A continuación se muestran algunos ejemplos:
NLSSORT (first_name||’ ‘||last_name, ‘NLS_SORT=Generic_M_CI’) --1

NLSSORT (first_name||’ ‘||last_name, ‘NLS_LANGUAGE=French’) --2
NLSSORT (first_name||’ ‘||last_name, ‘NLS_LANG=F’) --3
En el primer ejemplo, se utiliza la ordenación original Generic_M incluyendo ordenación

sensible a acentos e insensible a mayúsculas. En el segundo ejemplo, se utiliza una
ordenación sensible a acentos y a mayúsculas. La ordenación por defecto del francés se
define en un fichero de definición de idioma. En el tercer ejemplo, ‘F’ es la abreviatura
para el idioma francés.
La utilidad principal de la función NLSSORT será en las cláusulas ORDER BY y WHERE
cuando el valor del parámetro de sesión NLS_SORT sea diferente del de la sentencia
SQL. Los ejemplos anteriores podrían ser modificados para utilizar la función NLSSORT.
SQL> SELECT * FROM prueba ORDER BY NLSSORT(texto, ‘NLS_SORT=SPANISH’);

SQL> SELECT * FROM prueba ORDER BY NLSSORT(texto, ‘NLS_SORT=SPANISH_AI’);
SQL> SELECT * FROM prueba ORDER BY NLSSORT(texto, ‘NLS_SORT=SPANISH_CI’);
CÁLCULOS INTER-FILAS EN SQL

Las consultas SQL pueden incluir sintaxis nueva que permite cálculos complejos
semejantes a los realizados mediante hojas de cálculo. Estos cálculos tratan a las tablas
relacionales como si fuesen arrays de n dimensiones, permitiendo cálculos complejos a la
vez que evitan joins y uniones múltiples. Es posible utilizar dichos cálculos tanto sobre
tablas relacionales como sobre entornos de trabajo analíticos de Oracle OLAP.
BENEFICIOS
• Las hojas de cálculo son herramientas de elevada productividad personal,
mediante las cuales se pueden construir complejos modelos de cálculo.
• Sin embargo, adolecen de un gran problema de escalabilidad cuando el número
de fórmulas y/o la cantidad de datos es muy elevada.
• Las hojas de cálculo de sobremesa no tienen acceso a las capacidades de
procesamiento en paralelo de los servidores.
• En un entorno empresarial, donde existen múltiples hojas de cálculo, la
consolidación de los datos es complicada, y puede resultar costoso obtener una
impresión rápida del negocio accediendo a múltiples hojas de cálculo.
Oracle resuelve estos problemas introduciendo cálculos tipo hoja de cálculo en SQL.
CLÁUSULA SPREADSHEET
Oracle Database 10g incorpora a la sintaxis SQL la cláusula SPREADSHEET para integrar
toda la funcionalidad de cálculos inter-filas en el servidor. Esta cláusula supone una
mejora de SQL permitiendo realizar cálculos tipo hoja de cálculo desde SQL dentro del
servidor Oracle.
La cláusula SPREADSHEET permite mostrar las filas seleccionadas como un array
multidimensional así como acceder aleatoriamente a celdas del array, especificando unas
asignaciones de celdas, referidas como reglas, que ejecutan cálculos sobre celdas
individuales o sobre rangos de celdas. Estas reglas operan sobre los resultados de la
consulta y no modifican ninguna tabla de la base de datos.
La cláusula SPREADSHEET ofrece toda la flexibilidad para:
• Direccionamientos simbólicos de celdas.
• Cálculos simbólicos sobre un array.
• UPSERT/ UPDATE por reglas.
• Construcciones bucle.
• Cálculos ordenados.
• Referencia a Hojas de Cálculo.
• Ordenamiento de reglas automático.
• Resolución recursiva de un modelo.
• Soporte de vistas materializadas.
TERMINOLOGÍA
Las columnas de una tabla o subconsulta se clasifican en tres grupos: columnas de
particionamiento, columnas de dimensiones y columna de medidas. Las medidas pueden
ser tratadas como celdas en un array de n dimensiones.
• Una clave de dimensión es una expresión en la cláusula DIMENSION BY.
• Una clave de partición es una expresión en la cláusula PARTITION BY.
• Una medida es una expresión nombrada en la cláusula MEASURES.
• Una referencia puntual es una referencia a una única celda.
El siguiente ejemplo muestra una referencia en una hoja bidimensional a la celda que muestra la suma de
ventas (s) del producto (p) Shorts, para el año (y) 2000
s[p=‘Shorts’, y=2000]
• Una regla de hoja de cálculo es una definición de una asignación.

El siguiente ejemplo especifica que las ventas de Shorts en el 2000 es la suma de ventas de los años 1998 y
1999.
s[p=‘Shorts’, y=2000] = s[p=‘Shorts’, y=1998] + s[p=‘Shorts’, y=1999]
Los datos utilizados como ejemplo parten de la vista siguiente:
CREATE VIEW emp_dept_job AS

SELECT department_name, job_title, EXTRACT(YEAR FROM hire_date) año,
SUM(salary) suma, COUNT(salary) cuenta
FROM jobs NATURAL JOIN employees JOIN departments USING (department_id)
GROUP BY department_name, job_title, extract(YEAR FROM hire_date);
La consulta siguiente contiene una cláusula SPREADSHEET:
SELECT job_title, d, a, s
FROM emp_dept_job
SPREADSHEET
PARTITION BY (job_title)
DIMENSION BY (department_name d, año a)
MEASURES (suma s)
(s['Purchasing', 2000]=(s['Purchasing', 1997] + s['Purchasing', 1998] +
s['Purchasing', 1999])/3,
s['Sales', 2001]=s['Sales', 2000]);
Donde:
• La cláusula PARTITION provoca el particionado de los resultados por el campo
JOB_TITLE
• Las columnas DIMENSION se identifican como DEPARTMENT_NAME y AÑO
• La clave MEASURES identifica una medida, SALES, para la hoja de cálculo, y tiene
asignado un alias S
• La expresión S[`Purchasing’, 2000] es una referencia a una celda. En ella se hace
referencia al alias del campo MEASURE, y dentro de los corchetes se incluyen los
valores para las dimensiones definidas en la partícula DIMENSION.
• Esta consulta está prediciendo que para cada puesto, los sueldos del año 2000 del
departamento ‘Purchasing’ corresponderán a la media de los 3 años anteriores,
mientras que los sueldos del departamento ‘Sales’ para el año 2001 no variarán
con respecto al año 2000.
• La cláusula SPREADSHEET opera sobre el resultado de la consulta de
agrupamiento asociada a la vista, y no modifica ninguna tabla base.
REFERENCIAS
REFERENCIAS A CELDAS
Una referencia a una celda debe calificar todas las dimensiones de la partición, listadas
en la cláusula DIMENSION BY.
La referencia puede ser:
• Referencia Simbólica.
Las dimensiones se cualifican mediante una expresión booleana. Deben incluirse dentro de los corchetes
tantas condiciones como dimensiones hayan en la cláusula DIMENSION BY. Cada una de las condiciones
debe cualificas una única dimensión y debe incluir una única columna como predicado.
Es posible utilizar referencias a una o varias celdas. Una referencia a una celda se
cualifica utilizando un predicado de igualdad. Cualquier otra referencia con
predicados distintos a la igualdad implica una referencia múltiple.
S [d=’Sales’, a=2000]
• Referencia Posicional.
Las dimensiones se cualifican mediante su posición en la cláusula DIMENSION BY. Cada valor proporcionado
entre corchetes se asocia a la dimensión en la posición equivalente en la cláusula.
S [’Sales’, 2000]
Las referencias simbólica y posicional gestionan los valores nulos de forma diferente. Con
una referencia simbólica como s[d=NULL, y=2000], esto no cualifica a ninguna celda pues
la igualdad NULL=NULL nunca es cierta. Sin embargo, al utilizar la referencia por posición
s[NULL, 2000] si cualificará a una celda donde d IS NULL y y=2000.
REFERENCIAS A RANGOS
Es posible referenciar a un conjunto de celdas en la parte derecha de una regla, para
aplicar una operación de agrupamiento sobre dicho conjunto. Las referencias a rangos se
localizan a la derecha de la regla y no generan nuevas filas, realizando un bucle que
recorre las filas existentes.
El siguiente ejemplo muestra la suma de sueldos del departamento ‘Sales’ para el año
2000, así como la media de las sumas de sueldos de dicho departamento entre los años
1990 y 1999.
S[d=‘Sales’, a=2000] = avg(s) [d=‘Sales’, y BETWEEN 1990 AND 1999]
PREDICADOS IS ANY Y ANY

El predicado IS ANY proporciona un rango abierto en ambos loados, realizando un bucle
sobre todos los valores de una dimensión. El ejemplo siguiente suma todos los sueldos
de todos los años en la partición del departamento ‘Sales’.
sum(s) [d=‘Sales’, y IS ANY] -- Simbólico

SuMMNOm(s) [‘Sales’, ‘ANY’] -- Posicional
FUNCIÓN CURRENTV()
La función CURRENTV() devuelve el valor actual de una dimensión desde el lado
izquierdo de una asignación. Es posible utilizar esta función para realizar una ordenación
relativa al valor de la dimensión a la izquierda de la regla.
S[‘Sales’, 2000] = s[CURRENTV(d), 1998] + s[CURRENTV(d), 1999]
En este ejemplo, las expresiones de la derecha muestran una referencia al valor actual
del departamento en la expresión de la izquierda, que es ‘Sales’. La siguiente expresión
es equivalente:
S[‘Sales’, 2000] = s[‘Sales’,1998] + s[‘Sales’, 1999]
La potencia de CURRENTV aumenta cuando la expresión de la izquierda en la regla se

refiere a un rango de celdas. El siguiente ejemplo muestra una regla que establece el
valor de 5 celdas:
S[‘Sales’, y BETWEEN 2001 AND 2005] = s[CURRENTV(d),CURRENTV(a)-2] +

s[CURRENTV(d),CURRENTV(a)-1]
Debe tenerse en cuenta:

• Es posible utilizar la función CURRENTV() en cualquier lugar del lado derecho,
proporcionando entre paréntesis el nombre de su argumento.
• Es posible utilizar la función CURRENTV() en una dimensión para referenciar el
predicado de otra dimensión, siempre y cuando los tipos de datos de ambas
dimensiones sean comparables.
• Es posible utilizar una construcción cíclica a la izquierda para especificar un rango
de celdas existentes mediante el uso de un predicado de única columna para
cualificar las filas existentes.
BUCLES CUALIFICADOS INCREMENTALES

Es posible utilizar un bucle FOR ... INCREMENT para realizar incrementos discretos
dentro de un rango de valores, mediante la siguiente sintaxis:
FOR dimension FROM val_ini TO val_fin INCREMENT <n>
El bucle puede ser descendente si se utiliza la palabra reservada DECREMENT en lugar de

INCREMENT, para disminuir los valores en el bucle.
El bucle debe aparecer a la izquierda de la asignación en la regla.
En el siguiente ejemplo, la expresión de la izquierda identifica un rango entre los años
2000 y 2005 con un valor incremental de 1 año. La expresión de la derecha representa,
para cada año, la suma de los dos años anteriores. Para el año 2002, su valor será la
suma de los años 2000 y 2001.
SQL>SELECT job_title, d, a, s FROM emp_dept_job

2 SPREADSHEET
3 PARTITION BY (job_title)
4 DIMENSION BY (department_name d, año a)
5 MEASURES (suma s)
6 (s['Sales', FOR a FROM 2001 TO 2005 INCREMENT 1] =
7 sum(s)['Sales', a BETWEEN CURRENTV()-2 AND CURRENTV()-1]);
JOB_TITLE D A S
------------------------- ---------- ---------- ----------
Sales Manager Sales 1996 14000
(…)
El operador INCREMENT se aplica a todos los tipos de datos que soporten sumas o
restas, o sea tipos de datos numéricos o de fecha.
Es posible utilizar el bucle FOR... INCREMENT con cadenas de texto. La sintaxis es
ligeramente diferente:
FOR dim LIKE <cadena_con_un_solo_%> FROM val_ini TO val_fin INCREMENT <n>
En este caso, la expresión <cadena_con_un_solo_%> debe contener un único carácter %.

Este carácter será reemplazado con el valor correspondiente de <n>, convertido a
carácter, durante la ejecución.
S[‘Sales’, 2000, FOR trimestre LIKE ‘T%’ FROM 1 TO 4 INCREMENT 1] =

S[‘Sales’, 1999, CURRENTV(trimestre)]
En esta regla, la suma de sueldos del departamento ‘Sales’ para cada uno de los
trimestres T1, T2, T3 o T4 del año 2000 será igual a la suma de sueldos para cada uno
de los trimestres del año 1999.
BUCLES DE SUBCONSULTA CUALIFICADOS

Es posible utilizar una subconsulta dentro de la construcción FOR para realizar un bucle
sobre una dimensión. Esto es útil para la densificación de datos, donde un procedimiento
garantiza que todos los valores de una dimensión están representados en la salida de la
consulta.
Deben tenerse en cuenta las siguientes recomendaciones:
• La subconsulta no debe estar relacionada.
• La subconsulta no puede ser una consulta definida mediante una cláusula WITH.
SQL> SELECT job_title, d, a, s, y_diff FROM emp_dept_job
2 SPREADSHEET IGNORE NAV
3 PARTITION BY (job_title) DIMENSION BY (department_name d, año a)
4 MEASURES (suma s, 0 y_diff) RULES UPSERT
5 (y_diff['Finance', FOR a IN (SELECT año FROM año)] =
6 s['Finance', CURRENTV()] - s['Finance', CURRENTV()-1])
7* ORDER BY job_title, d, a;
JOB_TITLE D A S Y_DIFF
------------------ ---------------- ---------- ---------- ----------
Accountant Finance 1985 0
(…)
En la vista EMP_DEPT_JOB pueden no estar presentes algunos años. Sin embargo, todos
los años deben estar presentes en la tabla AÑO (entre 1985 y 2000), que puede ser
utilizada en la subconsulta.
En el ejemplo, la cláusula UPSERT se utiliza para densificar los datos. Esta consulta
calcula la diferencia entre las sumas de sueldos del departamento ‘Finance’ del año actual
y del año anterior, tanto si están como si no están en la vista EMP_DEPT_JOB.
VALORES NULOS Y NO ENCONTRADOS

Hay dos tipos de valores indeterminados:
• Valores Nulos en una celda existente.
• Valores Indeterminados en una celda no encontrada.
Por defecto, los valores NULL reciben el mismo tratamiento que en el resto de cláusulas
SQL, excepto en referencias por posición, por ejemplo [NULL, NULL], que indica una
celda cuyas dos dimensiones toman el valor nulo.
Los valores no encontrados se tratan como NULL en referencias directas a celdas o como
valores no existentes en funciones de agregado.
El predicado IS PRESENT permite distinguir entre un valor NULL existente y un valor no
encontrado. Este predicado devuelve TRUE si la fila indicada por la referencia de la celda
existía antes de ejecutar la cláusula SPREADSHEET.
La siguiente consulta comprueba si existe la fila [‘Sales’, 1999], y si existe, la utiliza.
SQL> SELECT job_title, d, a, s FROM emp_dept_job

2 WHERE department_name='Sales'
3 SPREADSHEET
6 MEASURES (suma s)
7 ( s['Sales', 2000] = CASE WHEN s['Sales', 1999] IS PRESENT
8 THEN s['Sales', 1999] ELSE 0 END)
9 ORDER BY job_title, a;
JOB_TITLE D A S
----------------------------------- -------------------- ---------- ----------
Sales Representative Sales 1996 39500
Para influenciar el tratamiento de NULL y valores no encontrados, es posible utilizar:

• Función PRESENTV
• Función PRESENTNNV
• Cláusula IGNORE NAV
• Cláusula KEEP NAV.
Estas expresiones están disponibles únicamente dentro de la cláusula SPREADSHEET.
La función PRESENTV funciona de forma similar al predicado IS PRESENT. La función
acepta tres argumentos: una celda seguida de dos expresiones. Si la fila que contiene la
celda existe, devuelve la primera expresión; en caso contrario, devuelve la segunda
expresión.
s[‘Sales’, 2000] = PRESENTV (s[‘Sales’, 1999], s[‘Sales’, 1999], 0);
La función PRESENTNNV (present and not null) comprueba si la celda existe y no toma
un valor nulo. Si la celda existe se deja como está. Si no existe, se crea la celda y se le
asigna un valor.
s[‘Sales’, 2000] = PRESENTNNV (s[‘Sales’, 2000], s[‘Sales’, 2000], 10);
Las expresiones IGNORE NAV y KEEP NAV son opciones de la cláusula SPREADSHEET. Si
se especifica la opción IGNORE NAV, los valores nulos y no encontrados se inicializan a:
• 0 para datos numéricos.
• ‘01/01/2000’ para datos de fecha.
• ‘’ para datos tipo carácter.
La opción KEEP NAV es la opción por defecto y retorna un valor NULL para las referencias
de celdas no encontradas o para celdas con valores nulos.
El predicado IS PRESENT, al igual que las funciones PRESENTV y PRESENTNNV buscan la

existencia de una celda previamente a la ejecución de la cláusula SPREADSHEET.
SQL> CREATE TABLE x (a NUMBER, b NUMBER);

Table created.
SQL> INSERT INTO x VALUES (1,1);

1 row created.
SQL> SELECT * FROM x

2 SPREADSHEET DIMENSION BY (a) MEASURES (b)
3 RULES SEQUENTIAL ORDER (
4 b[2] = 2,
5 b[3] = CASE WHEN b[2] IS PRESENT THEN 3 ELSE 0 END);
A B
---------- ----------
1 1
2 2
3 0
Puesto que la celda [2] no existía antes del comienzo de la evaluación de las reglas, el
predicado b[2] IS PRESENT se evalúa como FALSE.
OPCIÓN UPDATE
Por defecto, las reglas de la cláusula SPREADSHEET tienen una semántica UPSERT. Esto
quiere decir que si la celda referenciada en el lado izquierdo existe, dicha celda es
modificada. Si no existe, se genera una nueva fila conteniendo dicha celda.
Es posible modificar el comportamiento por defecto mediante la opción UPDATE. En el
ejemplo siguiente, se asigna un valor a las celdas de los departamentos ‘Sales’ o
‘Finance’ del año 2000 como la suma de los valores de los años 1998 y 1999 para el
departamento actual. Si una fila no existe, no se ejecuta ninguna asignación ni creación
de la fila.
SQL> SELECT job_title, d, a, s

2 FROM emp_dept_job
3 WHERE department_name IN ('Sales', 'Finance')
4 SPREADSHEET
7 MEASURES (suma s) IGNORE NAV
8 RULES UPDATE
9 (s[FOR d IN ('Sales', 'Finance'), 2000] =
10 s[CURRENTV(d), 1998] + s[CURRENTV(d), 1999])
11 ORDER BY JOB_TITLE,D, A;
JOB_TITLE D A S
----------------------------------- -------------------- ---------- ----------
Finance Manager Finance 1994 12000

ORDEN DE EVALUACIÓN DE REGLAS

Si se especifica la cláusula SEQUENTIAL ORDER, el servidor Oracle evalúa las reglas en el
mismo orden en el que aparecen. En este caso, es posible asignar un valor a una celda
más de una vez. La cláusula SEQUENTIAL ORDER es la opción por defecto. Si se
especifica AUTOMATIC ORDER, el servidor Oracle evalúa las reglas en base a su orden de
dependencia. En este caso, solo es posible asignar un valor a una celda una única vez.
SQL> SELECT job_title, d, a, s FROM emp_dept_job

2 WHERE department_name='Sales'
3 SPREADSHEET
6 MEASURES (suma s) IGNORE NAV
7 RULES AUTOMATIC ORDER
8 (s['Sales', 2000] = s['Sales', 1998] + s['Sales', 1999],
9 s['Sales', 1999] = 50000,
10 s['Sales', 1998] = 40000)
11 ORDER BY job_title, a;
JOB_TITLE D A S
----------------------------------- -------------------- ---------- ----------
(…)
MEJORAS SQL DATA WAREHOUSE
EXTENSIONES A LA SENTENCIA MERGE

Hay dos mejoras importantes en la sentencia MERGE:
• Nuevas cláusulas condicionales, así como mejoras de las cláusulas ya existentes,
haciendo que la sentencia sea más fácil de usar y agilizando su ejecución.
 Cláusulas UPDATE o INSERT opcionales. Ahora es posible omitir alguna de las
cláusulas.
 Permite cláusulas UPDATE condicionales.
 Permite cláusulas INSERT condicionales.
 Reconocimiento y evaluación en tiempo de compilación de predicados ON, que
incluyen condiciones especiales.
• Cláusula opcional DELETE.
CLÁUSULAS INSERT O UPDATE OPCIONALES

Es posible omitir las cláusulas UPDATE o INSERT en una sentencia MERGE. En el ejemplo
siguiente, no se incluye la sentencia INSERT.
SQL> CREATE TABLE emp_hist AS SELECT * FROM employees WHERE 1=0;

Table created.
SQL> MERGE INTO emp_hist h USING employees e

2 ON (h.employee_id = e.employee_id)
3 WHEN MATCHED THEN UPDATE SET h.salary=e.salary;
3 WHEN NOT MATCHED THEN
4 INSERT (employee_id, first_name, last_name, email, hire_date, job_id,
5 department_id)
6 VALUES (e.employee_id, e.first_name, e.last_name, e.email, e.hire_date,
7 e.job_id, e.department_id);
CLÁUSULAS UPDATE CONDICIONALES

Es posible añadir una condición WHERE a la sentencia UPDATE, que compruebe una
condición cuando se desee no realizar la operación de UPDATE.
3 WHEN MATCHED THEN UPDATE SET h.salary=e.salary
4 WHERE h.salary<>e.salary;
CONDICIONES ON ESPECIALES
Para insertar todas las filas de la tabla origen en otra tabla sin unir ambas tablas origen y
destino, se puede utilizar el predicado ON constante.
En el siguiente ejemplo, la tabla NEW_PRODUCT será una copia vacía de la tabla
PRODUCTS excepto una columna renombrada.
MERGE INTO new_products np
USING products p
ON (1=0)
INSERT (np.prod_id, np.prod_new_status)
VALUES (p.prod_id, p.prod_status);
INSERT CONDICIONALES
Es posible añadir una condición WHERE a la sentencia INSERT, que compruebe una
condición cuando se desee no realizar la operación.
MERGE INTO emp_hist h USING employees e

ON (h.employee_id = e.employee_id)
INSERT (employee_id, first_name, last_name, email, hire_date, job_id,
department_id)
VALUES (e.employee_id, e.first_name, e.last_name, e.email, e.hire_date,
e.job_id, e.department_id)
WHERE e.commission_pct IS NOT NULL;
CLÁUSULA DELETE OPCIONAL

Es posible vaciar una tabla a la vez que se insertan o modifican datos mediante una
sentencia MERGE.
MERGE INTO emp_hist h USING employees e

ON (h.employee_id = e.employee_id)
WHEN MATCHED THEN
UPDATE SET h.salary=e.salary WHERE e.commission_pct IS NOT NULL
DELETE WHERE e.commission_pct IS NULL
INSERT (employee_id, first_name, last_name, email, hire_date, job_id,
department_id)
VALUES (e.employee_id, e.first_name, e.last_name, e.email, e.hire_date,
e.job_id, e.department_id)
WHERE e.commission_pct IS NOT NULL;
MEJORAS EN CONNECT BY
Oracle 10g incluye tres nuevas cláusulas para consultar jerárquicas:
• CONNECT_BY_ROOT
• CONNECT_BY_ISLEAF
• CONNECT_BY_ISCYCLE
CONNECT BY ROOT
A veces puede ser útil deshacer el camino hasta la fila inicial en una jerarquía. El
operador CONNECT_BY_ROOT permite referenciar valores de la fila inicial desde
cualquier fila en la jerarquía.
Uno de los usos de CONNECT_BY_ROOT puede ser identificar todos los productos que
contienen determinado componente (ej.: búsqueda de productos con un componente
defectuoso). Otro de los usos, mostrado en el ejemplo, permite obtener un porcentaje
referido al valor de la fila inicial.
SELECT LEVEL, first_name||' '||last_name nombre, salary,

ROUND(salary/(CONNECT_BY_ROOT salary)*100,0) percent
FROM employees
CONNECT BY ISLEAF
La pseudocolumna CONNECT_BY_ISLEAF permite conocer a priori si una fila contiene
filas dependientes, o es una fila “leaf”.
Esto permitiría, por ejemplo, habilitar una jerarquía de tipo drill-down mediante
hiperenlaces web para profundizar en los detalles.
SELECT rpad(' ', 2*(level-1))||first_name||' '||last_name apellido,

salary, DECODE(connect_by_isleaf,0,’SI’,’NO’) detalles
FROM employees
CONNECT BY ISCYCLE
Al consultar datos jerárquicos, es posible encontrar una jerarquía que es circular.
• Una consulta jerárquica circular provocará un error “ORA-01436 CONNECT BY

loop in user data”.
• La columna CONNECT_BY_ISCYCLE permite localizar las columnas causantes
del problema.
Por ejemplo, alguien puede asignar un jefe al empleado ‘King’, que hasta ahora no tenía
UPDATE employees
SET MANAGER_ID=156
WHERE EMPLOYEE_ID=100;
La siguiente consulta fallaría:
SELECT RPAD(' ', 2*(LEVEL-1))||first_name||' '||last_name apellido, salary

FROM employees
START WITH employee_id=100
...
APELLIDO SALARY
------------------------- ----------
John Russell 14000
ERROR:ORA-01436: bucle CONNECT BY en datos de usuario
La consulta incluyendo la pseudocolumna CONNECT_BY_ISCYCLE, marcará la/s

columna/s causantes del problema:
SELECT RPAD(' ', 2*(LEVEL-1))||first_name||' '||last_name apellido,

salary, connect_by_iscycle
FROM employees
START WITH employee_id=100
CONNECT BY NOCYCLE PRIOR employee_id=manager_id
APELLIDO SALARY CONNECT_BY_ISCYCLE
---------------------- ---------- ------------------
Karen Partners 13500 0
Janette King 10000 1
Patrick Sully 9500 0
(...)
D
ANEXO D. Funciones SQL

TABLA DE CONTENIDOS
Introducción .......................................................................................................................1
Funciones Numéricas ............................................................................................................ 1
Funciones de cadena de caracteres que devuelven caracteres ........................................... 4
Funciones de cadena de caracteres que devuelven números.............................................. 7
Funciones de fecha y hora .................................................................................................... 8
Funciones de conversión..................................................................................................... 12
Otras funciones. .................................................................................................................. 16
ANEXO D. Funciones SQL D-1
INTRODUCCIÓN
A continuación se relacionan las funciones SQL más comunes clasificadas según los
grupos siguientes:
• Funciones Numéricas
• Funciones de cadena de caracteres que devuelven caracteres
• Funciones de cadena de caracteres que devuelven números
• Funciones de fecha y hora
• Funciones de conversión
• Otras funciones
FUNCIONES NUMÉRICAS
Sintaxis ABS(n)
Propósito Devuelve el valor absoluto de n.
ABS SQL> SELECT ABS(-25) FROM DUAL;
ABS(-25)
Ejemplo
----------
25
Sintaxis ACOS(n)
Propósito Devuelve el coseno del arco de n.
ACOS SQL> SELECT ACOS(.25) FROM DUAL;
ACOS(.25)
Ejemplo ----------
1,31811607
Sintaxis ASIN(n)
Propósito Devuelve el seno del arco de n.
ASIN SQL> SELECT ASIN (.25) FROM DUAL;
ASIN(.25)
Ejemplo ----------
,252680255
Sintaxis ATAN(n)
Propósito Devuelve la tangente del arco de n.
ATAN SQL> SELECT ATAN(.25) FROM DUAL;
ATAN(.25)
Ejemplo
----------
,244978663
Sintaxis ATAN2(N,M)
Propósito Devuelve la tangente del arco de n y m.
ATAN2 SQL> SELECT ATAN2(.25,.3) FROM DUAL;
ATAN2(.25,.3)
Ejemplo
-------------
,694738276
Sintaxis ATAN2(N,M)
ATAN2
Propósito Devuelve la tangente del arco de n y m.
D-2 ANEXO D. Funciones SQL
SQL> SELECT ATAN2(.25,.3) FROM DUAL;

ATAN2(.25,.3)
Ejemplo
-------------
,694738276
Sintaxis BITAND(arg1,arg2)
Devuelve el resultado de la operación lógica AND
entre argumento1 y argumento2, expresados en
Propósito
notación binaria. Se suele utilizar con la función
BITAND DECODE.
SQL> SELECT bitand(4,7) FROM DUAL;
BITAND(4,7) 100 111
Ejemplo
-------------
4
Sintaxis CEIL(n)
Propósito Devuelve el entero superior o igual a n.
CEIL SQL> SELECT ceil(12.1) FROM DUAL;
CEIL(12.1)
Ejemplo
----------
13
Sintaxis COS(n)
Propósito Devuelve el coseno de n en radianes.
COS SQL> SELECT cos(180) FROM DUAL;
COS(180)
Ejemplo
----------
-,59846007
Sintaxis COSH(n)
Propósito Devuelve el coseno hiperbólico de n.
COSH SQL> SELECT cosh(0) FROM DUAL;
COSH(0)
Ejemplo
----------
1
Sintaxis EXP(n)
Propósito Devuelve el número e elevado a la potencia de n
EXP SQL> SELECT exp(3) FROM DUAL;
EXP(3)
Ejemplo
----------
20,0855369
Sintaxis FLOOR(n)
Propósito Devuelve el entero inferior o igual a n.
FLOOR SQL> SELECT floor(13.6) FROM DUAL;
FLOOR(13.6)
Ejemplo
-----------
13
Sintaxis LN(n)
Propósito Devuelve el logaritmo neperiano de n.
LN SQL> SELECT ln(27) FROM DUAL;
LN(27)
Ejemplo
----------
3,29583687
Sintaxis Log(M,N)
LOG
Devuelve el logaritmo en base m de n. M y n deben
Propósito
de ser enteros positivos y m!=0 y m!=1
SQL> SELECT log(10,1000) FROM DUAL;

LOG(10,1000)
Ejemplo
------------
3
Sintaxis MOD(m,n)
Propósito Devuelve el resto de m dividido entre n.
MOD SQL> SELECT mod(4,3) FROM DUAL;
MOD(4,3)
Ejemplo
----------
1
Sintaxis POWER(m,n)
Devuelve m elevado a la potencia n. Si m es
Propósito
POWER negativo, n debe de ser un numero entero.
SQL> SELECT power(10,3) FROM DUAL;
POWER(10,3)
Ejemplo
-----------
1000
Sintaxis ROUND(n,[m])
Devuelve n redondeado a m. Si se omite m por
Propósito
defecto es 0.
ROUND SQL> SELECT round(12.345,2) FROM DUAL;
ROUND(12.345,2)
Ejemplo
---------------
12,35
Sintaxis SIGN(n)
Si n>0 devuelve1. Si n=0 devuelve 0. Si n<0
Propósito
devuelve –1.
SIGN SQL> SELECT sign(-14) FROM DUAL;
SIGN(-14)
Ejemplo
----------
-1
Sintaxis SIN(n)
Propósito Devuelve el seno de n.
SIN SQL> SELECT sin(90) FROM DUAL;
SIN(90)
Ejemplo
----------
,893996664
Sintaxis SINH(n)
Propósito Devuelve el seno hiperbólico de n
SINH SQL> SELECT sinh(1) FROM DUAL;
SINH(1)
Ejemplo
----------
1,17520119
Sintaxis SQRT(n)
Propósito Devuelve la raíz cuadrada de n. n>0
SQL> SELECT sqrt(16) FROM DUAL;
SQRT
SQRT(16)
Ejemplo
----------
4
TAN(n)
TAN Sintaxis
Propósito Devuelve la tangente de n.
SQL> SELECT tan(45) FROM DUAL;

TAN(45)
Ejemplo
----------
1,61977519
Sintaxis TANH(n)
Propósito Devuelve la tangente hiperbólica de n.
TANH SQL> SELECT tanh(45) FROM DUAL;
TANH(45)
Ejemplo
----------
1
Sintaxis TRUNC(n,[m])
Devuelve n truncado a m decimales. Si se omite m
Propósito
el valor por defecto es 0.
TRUNC SQL> SELECT trunc(12.345,2) FROM DUAL;
TRUNC(12.345,2)
Ejemplo
---------------
12,34
Sintaxis WIDTH_BUCKET ( expr min, max , num )
Utilizado para la construcción de histogramas.
Compara los valores de expresión con los valores
Propósito
mínimo y máximo. En el caso de superar se asigna
el valor num.
SQL> SELECT FIRST_NAME,SALARY,
WIDTH_BUCKET(salary, 100, 10000,30) "Grupo"
WIDTH_BUCK FROM employees where department_id =30
ET order by salary;
FIRST_NAME SALARY Grupo
-------------------- ---------- ----------
Ejemplo Karen 2500 8
Guy 2600 8
Sigal 2800 9
Shelli 2900 9
Alexander 3100 10
Den 11000 31
FUNCIONES DE CADENA DE CARACTERES QUE DEVUELVEN CARACTERES
Sintaxis CHR(n, USING NCHAR_CS)

Devuelve el carácter cuyo número correspondiente
en binario es n. La transformación es en el juego de
Propósito
CHR caracteres de la base de datos o en el juego de
caracteres nacional.
SQL> SELECT chr(68) FROM DUAL;
C
Ejemplo
-
D
Sintaxis CONCAT(cadena1, cadena2)
Devuelve la cadena1 concatenada con la cadena2.
Propósito
Es equivalente al operador ||.
SQL> SELECT concat('Mi nombre es: ',first_name)
CONCAT Nombre
FROM employees;
Ejemplo
NOMBRE
----------------------------------
Mi nombre es: Steven
Sintaxis INITCAP(cadena)
Devuelve la primera letra de cada palabra en
Propósito
INITCAP mayúsculas. Palabras delimitadas por blancos.
SQL> SELECT initcap('el nombre') FROM DUAL;
INITCAP('
Ejemplo
---------
El Nombre
Sintaxis LOWER(cadena)
Devuelve la cadena de caracteres con todas las letras
Propósito
en minúsculas
LOWER SQL> SELECT lower('holA MUNdo') FROM DUAL;
LOWER('HOL
Ejemplo
----------
hola mundo
Sintaxis LPAD(cadena1,n,[cadena2])
Devuelve la cadena1 rellenada con el carácter por la
izquierda indicado en cadena2, hasta la longitud
Propósito
indicada en n. Si se omite la cadena2 se rellena hasta
LPAD la longitud con blancos.
SQL> SELECT lpad('Base',10,'*') FROM DUAL;
LPAD('BASE
Ejemplo
----------
******Base
Sintaxis LTRIM(cadena, muestra)
Borra los caracteres a la izquierda de la cadena de
Propósito caracteres hasta encontrar el primer carácter que no
LTRIM está en la muestra.
SQL> SELECT ltrim('pspspEl perro','ps') FROM DUAL;
LTRIM('P
Ejemplo
--------
El perro
Sintaxis NLS_INITCAP(cadena, parámetros NLS)
Devuelve la cadena de caracteres la primera letra de
Propósito cada palabra en mayúsculas. Dependiente de del
parámetro de ordenación NLS
NLS_INITCAP SQL> SELECT nls_initcap('ijs','NLS_SORT = XDutch')
FROM DUAL;
Ejemplo IJs
SQL> SELECT nls_initcap('ijs') FROM DUAL;
Ijs
Sintaxis NLS_LOWER(cadena, parámetros NLS)
Devuelve la cadena de caracteres en minúsculas.
Propósito
Dependiente de del parámetro de ordenación NLS
NLS_LOWER SQL> SELECT nls_lower('HOla','NLS_SORT = XDutch')
FROM DUAL;
Ejemplo NLS_
----
hola
Sintaxis NLSSORT(cadena, parámetros NLS)

Devuelve los datos ordenados dependiendo de los
Propósito
parámetros del lenguaje NLS.
SELECT * FROM test ORDER BY NLSSORT(nombre);

NOMBRE
---------------
NLSSORT Gaaciar
Gabia
Ejemplo SELECT * FROM test
ORDER BY NLSSORT(nombre, 'NLS_SORT = XDanish');
NOMBRE
---------------
Gabia
Gaaciar
Sintaxis NLS_UPPER(cadena, parámetros NLS)

Devuelve la cadena de caracteres en mayúsculas.
Propósito
Dependiente de del parámetro de ordenación NLS
NLS_UPPER SQL> SELECT NLS_UPPER('HOla','NLS_SORT = XDutch')
FROM DUAL;
Ejemplo NLS_
----
HOLA
Sintaxis REPLACE(cadena, c1,[c2]))
Busca en la cadena el carácter c1 y lo remplaza por
Propósito
c2.
REPLACE SQL> SELECT REPLACE('perro','rr','l') FROM DUAL;
REPL
Ejemplo
----
pelo
Sintaxis RPAD(cadena1,n,[cadena2])
Devuelve la cadena1 rellenada por la derecha con el
carácter indicado en cadena2, hasta la longitud
Propósito
indicada en n. Si se omite la cadena2 se rellena hasta
RPAD la longitud con blancos.
SQL> SELECT RPAD('Base',10,'*') FROM DUAL;
RPAD('BASE
Ejemplo
----------
Base******
Sintaxis RTRIM(cadena, muestra)

Borra los caracteres a la derecha de la cadena de
Propósito caracteres hasta encontrar el primer carácter que no
RTRIM está en la muestra.
SQL> SELECT RTRIM('El perropspsp','ps') FROM DUAL;
RTRIM('P
Ejemplo
--------
El perro
Sintaxis SOUNDEX(cadena)
Devuelve una cadena de caracteres conteniendo la
Propósito representación fonética de los caracteres. Basado en
el idioma inglés.
SOUNDEX SELECT last_name FROM hr.employees
WHERE SOUNDEX(last_name) = SOUNDEX('SMYTHE');
LAST_NAME
Ejemplo --------------
Smith
Sintaxis SUBSTR(cadena,M,[N])
Devuelve una parte de la cadena, empezando por la
posición indicada en M y tantos caracteres como se
Propósito
indica en N.
SUBSTR Existen las funciones SUBSTRB, SUBSTRC
SQL> SELECT SUBSTR('papagayo',1,4) FROM DUAL;
SUBS
Ejemplo
----
papa
Sintaxis TRANSLATE(cadena, c1,c2)

Devuelve la cadena de caracteres con todas las
Propósito
ocurrencias de c1 reemplazadas por c2.
SQL> SELECT TRANSLATE('NUM123',
TRANSLATE '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
'9999999999XXXXXXXXXXXXXXXXXXXXXXXXXX')
Ejemplo FROM DUAL;
TRANSL
------
XXX999
Sintaxis TRIM(cadena,FROM cadena origen)
Elimina los caracteres indicados tanto en la parte
Propósito derecha como en la parte izquierda de la cadena de
caracteres origen.
TRIM SELECT TRIM (0 FROM 0009872348900) "TRIM Example"
FROM DUAL;
TRIM Example
Ejemplo ------------
98723489
Sintaxis UPEER(cadena)
Devuelve la cadena de caracteres con todas las letras
Propósito
en MAYÚSCULAS
UPPER SQL> SELECT UPPER('holA MUNdo') FROM DUAL;
LOWER('HOL
Ejemplo
----------
HOLA MUNDO
FUNCIONES DE CADENA DE CARACTERES QUE DEVUELVEN NÚMEROS

Sintaxis ASCII(cadena)
Devuelve la representación numérica del carácter
Propósito
indicado.
ASCII SQL> SELECT ASCII('A') FROM DUAL;
ASCII('A')
Ejemplo
----------
65
Sintaxis INSTR(cadena, c1,[N][,M]))
Busca en la cadena el carácter c1 empezando a
buscar por N y devuelve la posición M en la que
Propósito
aparece.
Existe también INSTRB.
INSTR SQL> SELECT INSTR('zaragoza','a',1,2) FROM DUAL;
INSTR('ZARAGOZA','A',1,2)
-------------------------
Ejemplo 4
Sintaxis LENGTH(cadena1)
Devuelve la longitud de la cadena, incluyendo los
Propósito
blancos..
SQL> SELECT LENGTH('hola mundo') FROM DUAL;
LENGTH
LENGTH('HOLAMUNDO')
Ejemplo -------------------
10
FUNCIONES DE FECHA Y HORA

Sintaxis ADD_MONTHS(fecha,n)
Devuelve la fecha mas los meses
Propósito
indicados en n
ADD_MONTHS SQL> SELECT ADD_MONTHS('27/05/78',6)
FROM DUAL;
Ejemplo ADD_MONT
--------
27/11/78
Sintaxis CURRENT_DATE
Devuelve la fecha actual, teniendo en
Propósito
cuenta la zona horaria. TIME_ZONE
ALTER SESSION SET TIME_ZONE = '-5:0';
SQL> SELECT CURRENT_DATE FROM DUAL;
CURRENT_DATE
CURRENT_DATE --------------------
12-MAR-2003 12:31:23
Ejemplo SQL> ALTER SESSION SET TIME_ZONE = '-
8:0';
SQL> SELECT CURRENT_DATE FROM DUAL;
CURRENT_DATE
--------------------
12-MAR-2003 09:31:41
Sintaxis CURRENT_TIMESTAMP(precision)
Devuelve la fecha y la hora actual en la
Propósito zona horaria de la sesión. La precisión
para los segundos por defecto es 6.
SQL> ALTER SESSION SET TIME_ZONE = '-
CURRENT_TIMESTAMP 5:0';
SQL> SELECT CURRENT_TIMESTAMP
Ejemplo FROM DUAL;
CURRENT_TIMESTAMP
----------------------------------------
13/03/03 04:19:22,007000 -05:00
Sintaxis DBTIMEZONE
Devuelve la zona horaria de la base de
datos. Este valor se establece en el
Propósito momento de creación de la base de datos.
Puede ser modificado con ALTER
DBTIMEZONE DATABASE.
SQL> SELECT DBTIMEZONE FROM DUAL;
DBTIME
Ejemplo
------
+01:00
EXTRACT
( { { AÑO
| MES
| DIA
| HORA
| MINUTOS
| SEGUNDOS
}
| { TIMEZONE_HOUR
Sintaxis
| TIMEZONE_MINUTE
}
| { TIMEZONE_REGION
EXTRACT | TIMEZONE_ABBR
}
}
FROM { expresión de fecha | expresión
interval }
)
Devuelve el valor especificado de una
Propósito
expresión de fecha o intervalo.
SQL> SELECT EXTRACT(YEAR FROM DATE '1995-
04-29') FROM DUAL;
Ejemplo EXTRACT(YEARFROMDATE'1995-04-29')
---------------------------------
1995
FROM_TZ ( timestamp_value ,
Sintaxis
time_zone_value )
Devuelve un valor timestamp conevertidoa a
Propósito
timestamp con TIME_ZONE
SQL> SELECT FROM_TZ(TIMESTAMP '2003-03-28
FROM_TZ 08:00:00', '5:00')
2 FROM DUAL;
Ejemplo FROM_TZ(TIMESTAMP'2003-03-2808:00:00','5:00')
-----------------------------------------------------------
-
28/03/03 08:00:00,000000000 +05:00
Sintaxis LAST_DAY(fecha)
Devuelve el ultimo día del mes que contenga la
Propósito
fecha especificada como argumento.
LAST_DAY SQL> SELECT SYSDATE,LAST_DAY(SYSDATE)
FROM DUAL;
Ejemplo SYSDATE LAST_DAY(SYSDATE)
-------------------- --------------------
13-MAR-2003 10:49:00 31-MAR-2003 10:49:00
Sintaxis LOCALTIMESTAMP(precision)
Devuelve la fecha y la hora actual con TIME
Propósito
ZONE en el formato de TIMESTAMP.
SQL> SELECT CURRENT_TIMESTAMP,
LOCAL LOCALTIMESTAMP FROM DUAL;
TIMESTAMP CURRENT_TIMESTAMP LOCALTIMESTAMP
----------------------------------- --------------
Ejemplo ----------
13/03/03 04:52:34,092000 -05:00 13/03/03
04:52:34,092000
MONTHS_BETWEEN(fecha1, fecha2)
Sintaxis
Devuelve el número de meses entre las dos
Propósito
MONTHS_ fechas que recibe como argumentos.
SQL> SELECT
BETWEEN MONTHS_BETWEEN(SYSDATE+34,SYSDATE)
FROM DUAL;
Ejemplo
MONTHS_BETWEEN(SYSDATE+34,SYSDATE)
----------------------------------
1,09677419
Sintaxis NEW_TIME ( fecha , zona1 , zona2 )
Devuelve la fecha en la zona horaria
Propósito
especificada en el argumento zona2.
SQL> SELECT SYSDATE, NEW_TIME(SYSDATE,
NEW_TIME 'AST','PST') FROM DUAL;
SYSDATE NEW_TIME(SYSDATE,'AS
Ejemplo -------------------- --------------------
13-MAR-2003 11:16:04 13-MAR-2003
07:16:04
Sintaxis NEXT_DAY ( fecha , char )
Devuelve la fecha del día de la semana indicado
Propósito
en char a partir de la fecha indicada en fecha.
NEXT_DAY SQL> SELECT NEXT_DAY(SYSDATE,'DOMINGO')
FROM DUAL;
Ejemplo NEXT_DAY(SYSDATE,'DO
--------------------
16-MAR-2003 11:20:41
Sintaxis NUMTODSINTERVAL ( n , 'char_expr' )
Convierte el numero n en el tipo literal INTERVAL
Propósito DAY TO SECOND. 'DAY' ,'HOUR' ,'MINUTE' ,
NUMTODSINTER
'SECOND'
VAL SQL> SELECT NUMTODSINTERVAL (4,'DAY') FROM
DUAL;
Ejemplo NUMTODSINTERVAL(4,'DAY')
--------------------------------------------------
+000000004 00:00:00.000000000
Sintaxis NUMTOYMINTERVAL ( n , 'char_expr' )
Convierte el numero n en el tipo literal INTERVAL
Propósito
YEAR TO MONTH. ‘YEAR’ ,’MONTH’
NUMTOYMINTE SQL> SELECT NUMTOYMINTERVAL (4,'YEAR') FROM
RVAL DUAL;
Ejemplo NUMTOYMINTERVAL(4,'YEAR')
-------------------------------------------------
+000000004-00
Sintaxis ROUND ( FECHA [, formato ] )
Devuelve la fecha correspondiente al formato
Propósito especificado. Si se omite se muestra la fecha del
día siguiente.
ROUND SQL> SELECT SYSDATE,ROUND(SYSDATE, 'YEAR')
FROM DUAL;
SYSDATE ROUND(SYSD
Ejemplo ---------- ----------
13-03-2003 01-01-2003
Sintaxis SESSIONTIMEZONE
Devuelve el TIME ZONE (zona horaria) de la
Propósito
SESSIONTIMEZO sesión.
NE SQL> SELECT SESSIONTIMEZONE FROM DUAL;
SESSIONTIMEZONE
Ejemplo
--------------------------------------
-05:00
Sintaxis SYS_EXTRACT_UTC ( datetime_with_timezone

Devuelve la fecha UTC, de la fecha que recibe
Propósito como argumento con desplazamiento de zona
SYS_EXTRACT_ horaria.
UTC SQL> SELECT SYS_EXTRACT_UTC(TIMESTAMP '2000-
03-28 11:30:00.00 -08:00') FROM DUAL;
Ejemplo SYS_EXTRACT_UTC
-------------------------------------------------
28/03/00 19:30:00,000000000
Sintaxis SYSDATE
Devuelve la fecha y la hora actual. Devuelve un
Propósito
tipo de datos DATE
SYSDATE SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
Ejemplo ----------
13-03-2003
Sintaxis SYSTIMESTAMP
Devuelve la fecha y la hora del sistema y la zona
Propósito horaria. El tipo de datos devuelto es TIMESTAMP
SYSTIMESTAMP WITH TIME ZONE
SQL> SELECT SYSTIMESTAMP FROM DUAL;
SYSTIMESTAMP
Ejemplo
--------------------------------------
13/03/03 11:49:27,380000 +01:00
Sintaxis TO_DSINTERVAL ( char ['nlsparam'] )
Convierte la cadena de caracteres en el tipo de
Propósito
datos INTERVAL DAY TO SECOND.
TO_DSINTERVA SQL> SELECT TO_DSINTERVAL('100 10:00:00')
L FROM DUAL;
Ejemplo TO_DSINTERVAL('10010:00:00')
----------------------------------------------------
+000000100 10:00:00.000000000
Sintaxis TO_TIMESTAMP ( char [ , fmt ['nlsparam']]
Propósito
dato TIMESTAMP.
TO_TIMESTAMP SQL> SELECT TO_TIMESTAMP ('1999-12-01
11:00:00', 'YYYY-MM-DD HH:MI:SS') FROM DUAL;
Ejemplo TO_TIMESTAMP('19990','YYYY-MM-DDHH:MI:SS')
----------------------------------------------------------
01/12/99 11:00:00,000000000
Sintaxis TO_TIMESTAMP_TZ ( char[ ,fmt 'nlsparam']] )
Propósito
dato TIMESTAMP WITH TIME ZONE.
TO_TIMESTAMP SQL> SELECT TO_TIMESTAMP_TZ(SYSDATE)
_TZ FROM DUAL;
Ejemplo TO_TIMESTAMP_TZ(SYSDATE)
------------------------------------------------
13/03/20 03:12:26 -05:00
Sintaxis TO_YMINTERVAL ( char )

Propósito
datos INTERVAL YEAR TO MONTH.
TO_YMINTERVA SQL> SELECT hire_date, hire_date +
L TO_YMINTERVAL('01-02') FROM employees;
HIRE_DATE
Ejemplo -------------------- --------------------
17-JUN-1987 00:00:00 17-AGO-1988 00:00:00
21-SEP-1989 00:00:00 21-NOV-1990 00:00:00
Sintaxis TRUNC ( FECHA [, fmt] )
Devuelve la fecha truncada al formato
Propósito
especificado.
TRUNC SQL> SELECT SYSDATE, TRUNC(SYSDATE,'YEAR')
FROM DUAL;
Ejemplo SYSDATE TRUNC(SYSDATE,'YEAR'
-------------------- --------------------
13-MAR-2003 12:31:24 01-ENE-2003 00:00:00
TZ_OFFSET
( { 'time_zone_name'
| '{ + | - } hh : mi'
Sintaxis | SESSIONTIMEZONE
| DBTMEZONE
}
TZ_OFFSET )
Devuelve el desplazamiento de la zona horaria
Propósito
especificada.
SQL> SELECT TZ_OFFSET('US/Eastern') FROM DUAL;
TZ_OFFS
Ejemplo
-------
-05:00
FUNCIONES DE CONVERSIÓN
Sintaxis ASCIISTR(cadena)
Propósito Convierte la cadena de caracteres en ASCII
ASCIISTR SELECT ASCIISTR('ABÄCDE') FROM DUAL;
ASCIIS
Ejemplo
------
ABDCDE
Sintaxis
BIN_TO_NUM(expr[,expr]...)
Propósito
Convierte una cadena binaria de bits en un número.
BIN_TO_NUM
SQL> SELECT BIN_TO_NUM(1,0,1,1,0) FROM DUAL;
BIN_TO_NUM(1,0,1,1,0)
Ejemplo
---------------------
22
CAST({expr | (subquery)| MULTISET(subquery)}
Sintaxis
AS type_name)
Propósito Convierte un tipo de datos en otro tipo de datos.
SQL> SELECT CAST('22-OCT-1997' AS TIMESTAMP WITH
CAST LOCAL TIME ZONE) FROM DUAL;
CAST('22-OCT-1997'ASTIMESTAMPWITHLOCALTIMEZONE)
Ejemplo
-------------------------------------------------------------
22/10/97 00:00:00,000000
Sintaxis CHARTOROWID(char)
Convierte la cadena de caracteres en tipo de datos
Propósito
ROWID
SQL> SELECT last_name FROM employees
CHARTOROWID WHERE ROWID =
CHARTOROWID('AAAGwDAAEAAAABUAAA');
Ejemplo
LAST_NAME
-------------------------
King
Sintaxis COMPOSE('string')
La cadena de caracteres la convierte en una cadena de
Propósito
caracteres UNICODE.
COMPOSE SQL> SELECT COMPOSE ( 'o' || UNISTR('\0308') ) FROM
DUAL;
Ejemplo C
-
ö
Sintaxis CONVERT(char,dest_char_set[,source_char_set])
Propósito Convierte una cadena en un juego de caracteres a otro.
SQL> SELECT CONVERT('España', 'we8dec','us7ascii') FROM
CONVERT DUAL;
Ejemplo CONVER
------
Espaqa
Sintaxis DECOMPOSE('string' [CANONICAL | COMPATIBILITY])
Valida solo para cadenas de caracteres UNICODE.
Propósito Devuelve la cadena de caracteres de entrada en
DECOMPOSE UNICODE.
SELECT DECOMPOSE ('Châteaux') FROM DUAL;
DECOMPOSE
Ejemplo
---------
Cha^teaux
Sintaxis HEXTORAW ( char )
Convierte una cadena que contiene dígitos en
Propósito
HEXTORAW hexadecimal a un valor raw.
CREATE TABLE test (raw_col RAW(10));
Ejemplo
INSERT INTO test VALUES (HEXTORAW('7E6D'));
Sintaxis RAWTOHEX ( raw )
Convierte un valor raw una cadena que contiene dígitos
Propósito
en hexadecimal.
RAWTOHEX SQL> SELECT RAWTOHEX(raw_col) FROM test;
RAWTOHEX(RAW_COL)
Ejemplo --------------------
7E6D
Sintaxis RAWTONHEX ( raw )
Convierte un valor raw una cadena de juego de
Propósito caracteres nacional que contiene dígitos en
hexadecimal.
SQL> SELECT RAWTNOHEX(raw_col) FROM test;
RAWTONHEX RAWTOHEX(RAW_COL)
--------------------
Ejemplo 7E6D
Sintaxis ROWIDTOCHAR(rowid)
Convertir un tipo de dato ROWID a VARCHAR2. De la
Propósito conversión resulta siempre una cadena de 18
ROWIDTOCHAR caracteres de longitud.
SELECT ROWID FROM oficinas
WHERE ROWIDTOCHAR(rowid) LIKE '%Br1AAB%’
Ejemplo ROWID
------------------
AAAAZ6AABAAABr1AAB
Sintaxis TO_CHAR(f, [,formato [, ‘parametros_nls’] ])
Propósito Convierte una fecha f tipo DATE en un VARCHAR2 con la

máscara indicada en formato. Si se omite formato, la
fecha se convierte a en un valor VARCHAR2 en el
TO_CHAR, formato de fecha por defecto. Más adelante veremos los
conversión de “modelos de formato de fecha”. Parametros_nls
especifica el lenguaje en el cual se visualizan los
fechas
nombres y abreviaturas de los meses y días. El
parámetro se indica con: ‘NLS_DATE_LANGUAGE =
‘idioma’. Si se omite toma el idioma por defecto para la
sesión.
SELECT TO_CHAR(SYSDATE, 'Month DD, YYYY') "Hoy" FROM
Ejemplo DUAL
Hoy
-----------------
Julio 10, 2003
Sintaxis TO_CHAR(número[,formato [,‘parametros_nls’] ])
Propósito Convierte número de tipo NUMBER en un tipo de datos

VARCHAR2 con la máscara indicada en formato. Si se
TO_CHAR, omite formato, la fecha se convierte a en un valor
conversión de VARCHAR2 lo suficientemente grande para contener los
dígitos más significativos.. Más adelante veremos los
números
“modelos de formato numéricos”. ‘Parámetros_nls’
especifica los caracteres y elementos de formatos de
números que se visualiza (separador de decimales, de
grupo, símbolo de la moneda local e ISO).
SELECT TO_CHAR(-10000, ‘L99G999D99MI’) “Cantidad” FROM
Ejemplo DUAL;
Cantidad
-----------------
$10,000.00-
Sintaxis TO_DATE(char,[,formato] [,’parametros_nls’] ])
Propósito Convierte una cadena tipo CHAR o VARACHAR2 en un

valor tipo DATE. El formato es la máscara de la fecha. Si
se omite toma el formato por defecto. Si el formato es J
para juliano char debe ser un entero. ‘Parámetros_nls’
TO_DATE tiene la misma función que para TO_CHAR en conversión
a fechas. No utilizar con TO_DATE un valor tipo DATE
como argumento. La fecha que devuelve puede tener un
valor diferente que el char original, dependendo del
formato indicado o el activo por defecto.
SELECT TO_DATE('January 15, 1997’, ,'Month dd, YYYY') Hoy
Ejemplo FROM DUAL
Hoy
-----------------
January 15, 1997
Sintaxis TO_MULTI_BYTE (char)
Propósito Devuelve char con todos sus caracteres de byte simple

convertidos en sus correspondientes caracteres
TO_MULTI_BYTE multibyte. Solo se utiliza en B.D. que utilicen ambos
tipos de juegos de caracteres.
SELECT TO_MULTI_BYTE('1234567') "Numero" FROM DUAL
Ejemplo Numero
-----------------
1234567
Sintaxis TO_SINGLE_BYTE (char)
Propósito Devuelve char con todos sus caracteres multibyte

convertidos en sus correspondientes caracteres de byte
simple. Solo se utiliza en B.D. que utilicen ambos tipos
TO_SINGLE_BYTE de juegos de caracteres.
SELECT TO_SINGLE_BYTE('1234567') "Numero" FROM
Ejemplo DUAL
Numero
-----------------
1234567
Sintaxis TO_NUMBER(char[,formato [,’parametros_nls’] ])
TO_NUMBER Propósito Convierte char de un valor CHAR o VARCHAR2 a un

tipo de dato NUMBER con el formato especificado.
UPDATE emp SET sal = sal +

Ejemplo TO_NUMBER(‘100.00’,’9G999D99’)
WHERE ename=’BLAKE’
OTRAS FUNCIONES.
DUMP Sintaxis DUMP(expr, [,formato [,posic_comienzo [,long] ] ])
Propósito Devuelve un VARCHAR2 conteniendo el código del tipo de dato, la
longitud en bytes y la representación interna del dato. El argumento
formato indica la notación en la que se visualiza el resultado.
Formato puede tener los siguientes valores:
8 Devuelve el resultado en notación octal.
10 Devuelve el resultado en notación decimal.
16 Devuelve el resultado en notación hexadecimal.
17 Devuelve el resultado en formato carácter simple.
Ejemplo
SELECT DUMP(ename, 8, 3, 2) "Ascii" FROM emp WHERE ename=’SCOTT’

Ascii
-------------------------
Type=1 Len=5: 79,84
SELECT DUMP(ename, 16) "Hexad" FROM emp WHERE empno=7894

Hexad
-------------------------
Type=1 Len=5: 4f,54
EMPTY_[B|C]LOB
Sintaxis EMPTY_[B|C]LOB()
Propósito Se muestra un localizador de LOB que se utiliza para inicializar el
valor de una variable, o para inicializar una columna LOB en una
sentencia UPDATE o INSERT y dejarla vacía. No se puede utilizar el
localizador que devuelve como parámetro en el paquete DBMS_LOB.
Ejemplo
UPDATE tab_lob1
SET col_clob = EMPTY_CLOB();
BFILENAME
Sintaxis BFILENAME(‘directorio’,’fichero’)
Propósito Devuelve el localizar BFILE asociado con el fichero binario físico LOB
que reside en el sistema de ficheros del S.O. El directorio es un
objeto de la base de datos que identifica ficheros externos a dicha
B.D. ‘Fichero’ es el nombre del fichero en el sistema operativo. Se
debe asociar primero al BFILE con un fichero físico antes de realizar
operaciones con SQL, PL/SQL, el paquete DBMS_LOB u OCI.
Ejemplo
INSERT INTO tbl_ficheros VALUES(BFILENAME(‘dir1_lob’ ‘image1.gif’));

GREATEST
Sintaxis GREATEST(expr [,expr2]....)
Propósito Devuelve el mayor valor de una lista de expresiones. Compara
carácter a carácter. El tipo de dato es siempre VARCHAR2.
Ejemplo
SELECT GREATEST('GUTIEZ','GUTIERREZ') "Mayor" FROM DUAL;

Mayor
-----------------
GUTIEZ
LEAST Sintaxis LEAST(expr [,expr2]...)

Propósito Devuelve menor valor de una lista de expresiones. Compara carácter
a carácter. El tipo de dato es siempre VARCHAR2.
Ejemplo
SELECT LEAST('GUTIEZ','GUTIERREZ') "Menor"

FROM DUAL;
Menor
-----------------
GUTIERREZ
NLS_CHARSET_DECL_LEN
Sintaxis NLS_CHARSET_DECL_LEN(bytecnt, csid)

Propósito Indica la longitud de declaración (en número de caracteres) de una
columna NCHAR. El parámetro bytecnt es la longitud de la columna.
El parametro csid es el identificativo del juego de caracteres
utilizado en la columna.
Ejemplo
SELECT NLS_CHARSET_DECL_LEN(200, nls_charset_id(‘jaa16eucfixed’)) COLUMNA_NLS

FROM DUAL;
COLUMNA_NLS
-----------
100
NLS_CHARSET_ID
Sintaxis NLS_CHARSET_ID(texto)
Propósito Muestra el identificativo del juego de caracteres utilizado
correspondiente a el juego indicado en texto. El parámetro texto es
un VARCHAR2. Si se le indica como texto ‘CHAR_CS’ devuelve el
número identificativo del juego de caracteres de la b.d. (servidor). Si
se le indica como parámetro ‘NCHAR_CS’ muestra el número
identificativo del juego de carácter nacional. Los juegos de
caracteres no válidos devuelven NULL.
Ejemplo1
SELECT NLS_CHARSET_ID(‘char_cs’) FROM DUAL;

NLS_CHARSET_ID(‘CHAR_CS’)
-------------------------
2
Ejemplo
SELECT NLS_CHARSET_ID(‘nchar_cs’) FROM DUAL;

NLS_CHARSET_ID(‘NCHAR_CS’)
-------------------------
1001
NLS_CHARSET_NAME
Sintaxis NLS_CHARSET_NAME(n)
Propósito Muestra el juego de caracteres NLS correspondiente al número que
se indica como parámetro. Si n no es un valor válido, se devuelve un
nulo.
Ejemplo
SELECT NLS_CHARSET_NAME(2) FROM DUAL;

NLS_CH
------
WE8DEC
NVL
Sintaxis NVL(expr1 ,expr2)
Propósito Indica el valor que ha de tener expr1 cuando en su contenido
aparezcan nulos. El tipo de dato que retorna expr2 es siempre el
mismo que tenga expr1.
Ejemplo
SELECT codigo_prod, NVL(precio, 0) Precio FROM productos

CODIGO_PROD Precio
----------- -----------------
10 40
20 200
30 0
40 340
50 0
VSIZE
Sintaxis VSIZE(expr)
Propósito Devuelve el número de bytes que ocupa la representación interna
del dato.
Ejemplo
SELECT ename, VSIZE(ename) "Bytes" FROM emp

Ename Bytes
---------- ------
PEPE 4
LOPEZ 5
DECODE
Sintaxis Decode(expr, val1, cod1, ...valn, codn, codf)
Propósito Dentro de una expr evalúa los valores de la lista y los cambia por el
código correspondiente.
Ejemplo
SELECT codigo_prod, DECODE(Codigo_prod,20,'Bebidas'

,40, 'Infantil','General') "Códigos"
FROM productos;
CODIGO_PROD Códigos
----------- -------------
10 General
20 Bebidas
30 General
40 Infantil
E
Ejercicios Lenguaje SQL. ORN-101

TABLA DE CONTENIDOS
Modelo de datos ................................................................................................................1

Ejercicios con la sentencia select.................................................................................... 1
Select ‘simples’ ...................................................................................................................... 1
Subconsultas/joins ................................................................................................................. 2
Ejercicios dml ....................................................................................................................3
Insert ...................................................................................................................................... 3
Update ................................................................................................................................... 3
Delete .................................................................................................................................... 3
Control de transacciones.................................................................................................. 3
Ejercicios ddl e integridad de datos. ............................................................................... 4
Implementación de restricciones de integridad durante la creación de una tabla ................ 4
Implementación de restricciones de integridad después de creación de una tabla.............. 4
Utilización de la tabla de excepciones .................................................................................. 5
Solución a los ejercicios ...................................................................................................6
Select simples........................................................................................................................ 6
Subconsultas / joins ............................................................................................................... 8
Insert .................................................................................................................................... 10
Update ................................................................................................................................. 11
Delete .................................................................................................................................. 11
Implementación de restricciones de integridad durante la creacion de una tabla .............. 11
Utilización de la tabla de excepciones ................................................................................ 12
MODELO DE DATOS
Ejercicios Lenguaje SQL. ORN-101 E-1
EJERCICIOS CON LA SENTENCIA SELECT.
SELECT ‘SIMPLES’
1. Mostrar el salario anual y el apellido de los empleados.
2. ¿Qué día fue hace 3 semanas?
3. Mostrar el trabajo, el apellido y el salario de los empleados ordenados por tipo de

trabajo y por salario descendente.
4. Mostrar los nombres de los empleados del departamento 10 y el número de

meses que llevan trabajando para la empresa.
5. Mostrar los nombres de los empleados y el número de días que llevan trabajando
para la empresa, cuyo salario sea mayor de 2.000$.
6. Mostrar el nombre del empleado y la posición en la que aparece la primera letra

“E” en dicho nombre, para aquellos empleados cuya comisión sea nula.
7. Mostrar el nombre del empleado y su fecha de alta en la empresa con formato Día
(nombre del día) / Mes (nombre del mes) / YYYY (cuatro dígitos del año) que
desempeñen el trabajo de “IT_PROG”.
8. ¿Qué día de la semana naciste?
9. Mostrar el nombre del empleado y el número de su departamento. Si es el 10

debe aparecer el literal “Contabilidad”, si es el 20 “Investigación”, si es el 30
“Ventas” y si es el 40 “Operaciones”.
10. Mostrar el nombre del empleado y una columna que contenga el salario
multiplicado por la comisión cuya cabecera sea “Bono”, si el empleado no tiene
comisión asignarle 0 en la columna ‘Bono’.
11. Mostrar el salario medio de aquellos empleados cuyo trabajo sea el de “IT_PROG”.
12. Encontrar, entre los empleados, el salario más alto, el más bajo y la diferencia
entre ambos.
13. Hallar el número de trabajos distintos que existen en el departamento 30.
14. Encontrar que departamentos tienen al menos dos trabajos distintos.
15. Encontrar el número de trabajos diferentes, que se desempeñan en el

departamento 30, para aquellos empleados cuyo salario se comprende entre
1.000 y 7.800$.
16. Contar el número de personas que realizan un trabajo determinado, dentro de

cada departamento.
E-2 Ejercicios Lenguaje SQL. ORN-101
SUBCONSULTAS/JOINS
1. Mostrar el nombre de los empleados, número y nombre de departamento, número
y los tres primeros caracteres de la localidad donde se encuentra el
departamento, para aquellos empleados que trabajen en el departamento 20 o
que sea vendedor (que su trabajo comience por ‘SA’).
2. Mostrar el nombre del empleado, identificador de trabajo, el nombre y código del

departamento en el que trabaja.
3. En la consulta anterior existen departamentos que no tienen empleados. Mostrar

también esta información.
4. Obtener para cada empleado, el nombre del Jefe para quien trabaja mediante una
recuperación jerárquica. El formato presentado debe estar tabulado según el nivel
del empleado.
5. Nombre completo del empleado que más gana.
6. Mostrar el nombre, el trabajo y el salario de todos los empleados que tienen un

salario superior al salario más bajo del departamento 30. Ordenar la recuperación
por orden descendente de salarios.
7. Encontrar quienes son los trabajadores que tienen por jefe a ‘King’.
8. Nombre del día de la semana en el que más empleados entraron a la empresa.
9. Encontrar el nombre, trabajo, salario y fecha de alta de aquellos empleados que

cobren más que cualquier vendedor (job_id ‘SA…’). Ordenar la salida por orden
descendente de salarios.
10. Encontrar el nombre, departamento, salario y trabajo de aquellos empleados que

trabajan en el mismo departamento que ‘Irene’, y cuyo salario es menor a la
media de los salarios del departamento 10.
11. Mostrar el nombre del empleado y la localidad donde trabaja, para los que tengan
comisión o que trabajen en el mismo departamento que ‘Irene’.
12. Recuperar los empleados cuyos salarios exceden la media de sus respectivos
departamentos.
13. Recuperar el empleado que más tarde entró para cada uno de los departamentos
existentes en la empresa.
14. Mostrar los nombres de departamentos, trabajos, la suma de salarios de ambos

campos, la suma total y el número de personas que hay en cada departamento,
Poner el literal "media sal", "media job", en cada una de las filas
correspondientes.
EJERCICIOS DML
INSERT
1. Insertar los siguientes datos en las tablas correspondientes:
a. Un empleado para la ciudad de ‘Madrid’, que trabaje en el departamento
de ‘Formación’ y su trabajo sea ‘Formador Oracle’.
b. Un empleado para la ciudad de ‘Barcelona’ que trabaje en el departamento
de ‘Viajes’ y su trabajo sea ‘Agente de Viajes Nacionales’.
UPDATE
1. Actualizar el salario de los empleados que trabajen en el departamento de ‘Matos’.
Asignarle un salario igual al incremento de un 15% respecto a la media de los
salarios del departamento 20.
2. Dejar la fecha de alta del empleado igual a la fecha del sistema para aquellos
empleados de la ciudad con código 1500 y cuyo salario sea superior a la media de
los salarios de analistas de la empresa.
3. Establecer al empleado ‘Jones’ como ANALISTA del departamento 20 y con un

incremento del 13% de su salario, (suponemos un único Jones).
DELETE
1. Borrar los empleados cuyo salario sea inferior a 5000$.
CONTROL DE TRANSACCIONES.
Si las inserciones, modificaciones y borradores se han realizado correctamente,
validar las sentencias anteriores.
EJERCICIOS DDL E INTEGRIDAD DE DATOS.
IMPLEMENTACIÓN DE RESTRICCIONES DE INTEGRIDAD DURANTE LA CREACIÓN DE UNA TABLA

1. Crear las siguientes tablas, implementar las siguientes reglas:
TABLA HABITACIONES
Nº HABITACIÓN NUMBER(2) Clave primaria

TIPO VARCHAR2(15) Check
PRECIO NUMBER(9)
TABLA CLIENTES
Nº CLIENTE NUMBER(4) Clave primaria

NIF NUMBER(8) Clave única
NOMBRE_CLIENTE VARCHAR2(90)
NVISA NUMBER(4)
TELÉFONO NUMBER(9)
TABLA RESERVAS
Nº RESERVAS NUMBER(2) Clave primaria

Nº CLIENTE NUMBER(4) Foreign Key (tabla clientes)
Nº HABITACION NUMBER(2) Foreign Key (tabla Habitaciones)
PAGAGO CHAR(2) Check
IMPLEMENTACIÓN DE RESTRICCIONES DE INTEGRIDAD DESPUÉS DE CREACIÓN DE UNA TABLA
TABLA HABITACIONES
Nº HABITACION PRIMARY KEY

TIPO Solo recogerá los valores de Simple o doble.
TABLA CLIENTES
Nº CLIENTE PRIMARY KEY

NIF Clave única.
TABLA RESERVAS
Nº RESERVAS PRIMARY KEY

Nº CLIENTE FOREIGN KEY. Este campo está relacionado con tabla CLIENTES.
Nº HABITACIÓN FOREIGN KEY. Este campo está relacionado con HABITACIONES.
PAGADO Solo admitirá los valores de ‘s’,’n’ (‘ si ‘o ‘no’)
UTILIZACIÓN DE LA TABLA DE EXCEPCIONES
1. Desactivar la restricción PRIMARY KEY para el campo NÚMERO DE CLIENTES

2. Insertar un nuevo número de cliente duplicado.
3. Crear la tabla exceptions mediante la ejecución del fichero utlexcpt.sql
4. Intentar activar la restricción PRIMARY KEY insertando las filas que no cumplan la
restricción en la tabla de excepciones.
5. Depurar la información eliminando duplicados.
6. Intentar activar la restricción.
SOLUCIÓN A LOS EJERCICIOS
SELECT SIMPLES
1.
SELECT salary “Salario”, last_name “Apellido”

FROM EMPLOYEES;
2.
SELECT SYSDATE - 21 “Día Hace Tres Semanas”

FROM DUAL;
3.
SELECT job_id “Trabajo”, last_name “Apellido”, salary “Salario”

FROM EMPLOYEES
ORDER BY job_id, salary DESC;
4.
SELECT last_name “Nombre”,

ROUND(MONTHS_BETWEEN (SYSDATE, hire_date)) “Meses Transcurridos”
FROM EMPLOYEES
WHERE department_id = 10;
5.
SELECT first_name "Nombre",

ROUND(SYSDATE - hire_date) "Días trabajando para Empresa"
FROM EMPLOYEES
WHERE Salary > 2.000;
6.
SELECT first_name "Nombre", INSTR(UPPER(first_name), 'E', 1) "Posicion

primera letra E"
FROM EMPLOYEES
WHERE Commission_pct IS NULL;
7.
SELECT first_name "Nombre", last_name "Apellido",

TO_CHAR (Hire_date, 'DAY/MONTH/YYYY') "Fecha de Alta"
FROM EMPLOYEES
WHERE job_id = ’IT_PROG’;
8.
SELECT TO_CHAR(TO_DATE('20 julio 1980','DD/MM/YYYY'),'DAY')

FROM DUAL;
9.
SELECT first_name "Nombre", department_id "Departamento",

DECODE (department_id, 10, 'Contabilidad', 20,
'Investigación', 30, 'Ventas', 40, 'Operaciones') "Nombre Depto"
FROM EMPLOYEES;
10.
SELECT first_name "Nombre", Salary*nvl(Commission_pct, 0) "Bono"

FROM EMPLOYEES;
11.
SELECT AVG(salary) "Media Salario"

FROM EMPLOYEES
WHERE job_id = 'IT_PROG';
12.
SELECT MAX (Salary) "Salario Máximo",

MIN (Salary) "Salario Mínimo",
MAX (Salary) - MIN (Salary) "Diferencia"
FROM EMPLOYEES;
13.
SELECT COUNT(DISTINCT(Job_id)) cantidad

FROM EMPLOYEES
WHERE department_id = 30 ;
14.
SELECT department_id,COUNT(DISTINCT(Job_id)) "cantidad"

FROM EMPLOYEES
GROUP BY department_id
HAVING COUNT(DISTINCT(Job_id))>=2;
15.
SELECT COUNT(DISTINCT Job_id) “Trabajos”

FROM EMPLOYEES
WHERE department_id = 30 AND
salary BETWEEN 1000 AND 7800;
16.
SELECT department_id, job_id, COUNT(*) “Personas”

FROM EMPLOYEES
GROUP BY department_id, job_id;
SUBCONSULTAS / JOINS
1.
SELECT first_name "Nombre", E.Department_id "Numero de

Departamento",department_name "Departamento", SUBSTR(Location_id, 1, 3)
FROM EMPLOYEES E, DEPARTMENTS D
WHERE (E.Department_id = D. Department_id) AND ( (E. Department_id = 20)
OR (job_id like 'SA%') );
2.
SELECT first_name “Nombre”, job_id “Trabajo”,

Department_name “Departamento”, D.department_id “Número Dept”
WHERE E.Department_id = D. Department_id;
3.
SELECT first_name “Nombre”, Job_id “Trabajo”,

Department_name “Departamento”, D.department_id “Número Dept”
WHERE E.Department_id(+) = D. Department_id;
4.
SELECT LPAD(' ',3*LEVEL) ||FIRST_NAME

FROM EMPLOYEES
START WITH MANAGER_ID IS NULL
CONNECT BY MANAGER_ID = PRIOR EMPLOYEE_ID
5.
SELECT first_name||’ ‘||last_name

FROM EMPLOYEES
WHERE Salary = (SELECT MAX(Salary)
FROM EMPLOYEES);
6.
SELECT first_name “Nombre”, job_id “Trabajo”, salary “Salario”

FROM EMPLOYEES
WHERE salary > ( SELECT MIN (Salary)
FROM EMPLOYEES
WHERE department_id = 30 )
ORDER BY salary DESC;
7.
SELECT first_name||’ ‘||last_name

FROM EMPLOYEES
WHERE manager_id IN (SELECT employee_id
FROM EMPLOYEES
WHERE last_name = ‘King’);
8.
SELECT TO_CHAR(hire_date, ‘DAY’)

FROM EMPLOYEES
GROUP BY TO_CHAR(Hire_date, ‘DAY’)
HAVING (COUNT(TO_CHAR(hire_date, ‘DAY’)))
= (SELECT MAX(COUNT(TO_CHAR(hire_date, ‘DAY’)))
FROM EMPLOYEES
GROUP BY TO_CHAR(hire_date, ‘DAY’));
9.
SELECT first_name||’ ‘||last_name, job_id, salary, hire_date

FROM EMPLOYEES
WHERE salary > (SELECT MAX (salary)
FROM EMPLOYEES
WHERE job_id LIKE ’SA%’)
ORDER BY salary DESC;
10.
SELECT first_name||’ ‘||last_name, department_name, salary, job_id

WHERE E.department_id=D.department_id
AND E.department_id = ( SELECT department_id
FROM EMPLOYEES
WHERE first_name = ‘Irene’ )
AND salary < ( SELECT AVG(salary)
FROM EMPLOYEES
WHERE department_id = 10 );
11.
SELECT first_name, location_id

WHERE E.department_id = D.department_id
AND (Commission_pct IS NOT NULL OR
E.department_id = (SELECT department_id
FROM EMPLOYEES
WHERE first_name = ‘Irene’));
12.
SELECT department_id, first_name||’ ‘||last_name, salary

FROM EMPLOYEES x
WHERE salary > (SELECT AVG(salary)
FROM EMPLOYEES
WHERE x.department_id = department_id )
ORDER BY department_id ;
13.
SELECT department_name, first_name||’ ‘||last_name, job_id,

TO_CHAR(hire_date, 'DD/MM/YY HH24:MI:SS') dia
FROM EMPLOYEES x
WHERE hire_date = ( SELECT MAX(hire_date) )
FROM EMPLOYEES
WHERE x.department_id = department_id )
ORDER BY department_id;
14.
SELECT DECODE(GROUPING(department_name),1,'suma de salarios *

trabajo',department_name) NOMBRES_DEPT,
decode(grouping(job_id),1,'suma de salariod * deptoname',job_id)
TRABAJOS,count(*),sum(salary)
WHERE E.department_id=D.department_id
GROUP BY cube(department_name,job_id);
INSERT
INSERT INTO COUNTRIES VALUES(‘ES’,’España’,1);
INSERT INTO LOCATIONS(LOCATION_ID,STREET_ADDRESS,POSTAL_CODE,CITY,

STATE_PROVINCE,COUNTRY_ID)
VALUES (3300,'Dr. Esquerdo, 34',28022,'Madrid','Madrid','ES');
INSERT INTO LOCATIONS(LOCATION_ID,STREET_ADDRESS,POSTAL_CODE,CITY,
STATE_PROVINCE,COUNTRY_ID)
VALUES 3400,'Gran Via, 23',80810,'Barcelona','Barcelona','ES');
INSERT INTO DEPARTMENTS(DEPARTMENT_ID,DEPARTMENT_NAME,MANAGER_ID,LOCATION_ID)

VALUES (280,’Formacion’,100,3300);
INSERT INTO DEPARTMENTS(DEPARTMENT_ID,DEPARTMENT_NAME,MANAGER_ID,LOCATION_ID)
VALUES (290,’Viajes’,100,3400);
INSERT INTO JOBS(JOB_ID,JOB_TITLE,MIN_SALARY,MAX_SALARY)

VALUES (‘FO_ORA’,’Formador Oracle’,2000,10000);
INSERT INTO JOBS(JOB_ID,JOB_TITLE,MIN_SALARY,MAX_SALARY)
VALUES (‘AG_VIA’,’Agente de Viaje’,3000,9000);
INSERT INTO EMPLOYEES(EMPLOYEE_ID,FIRST_NAME,LAST_NAME,EMAIL,PHONE_NUMBER,

HIRE_DATE,JOB_ID,SALARY,COMMISSION_PCT,MANAGER_ID,DEPARTMENT_ID)
VALUES (210,'Juan','Lopez','jlopez@cleformacion.com',913243675,sysdate,
'FO_ORA', 5000,.56,100,28);
INSERT INTO EMPLOYEES(EMPLOYEE_ID,FIRST_NAME,LAST_NAME,EMAIL,PHONE_NUMBER,
HIRE_DATE,JOB_ID,SALARY,COMMISSION_PCT,MANAGER_ID,DEPARTMENT_ID)
VALUES (211,'Laura','Gomez','lgomez@viajes.com',915244877,sysdate,'AG_VIA',
6000,NULL,100,290);
UPDATE
1.
UPDATE EMPLOYEES
SET salary = (SELECT AVG (salary) * 1.15
FROM EMPLOYEES
WHERE department_id = 20)
WHERE department_id = ( SELECT department_id
FROM EMPLOYEES
WHERE last_name = ’Matos’);
2.
UPDATE EMPLOYEES
SET hire_date = SYSDATE
WHERE department_id = (SELECT department_id
FROM DEPARTMENTS
WHERE location_id = 1500 )
AND salary > (SELECT AVG (salary)
FROM EMPLOYEES
WHERE job_id = ‘IT_PROG’);
3.
UPDATE EMPLOYEES
SET job_id = ‘IT_PROG’, salary = salary * 1.13
WHERE last_name = 'Jones';
DELETE
1.
DELETE FROM EMPLOYEES

WHERE Salary < 5000;
IMPLEMENTACIÓN DE RESTRICCIONES DE INTEGRIDAD DURANTE LA CREACION DE UNA TABLA

1.
CREATE TABLE habitaciones (num_hab NUMBER(2) CONSTRAINT pk_num PRIMARY KEY,

Tipo VARCHAR2(15) CONSTRAINT ck_tipo
CHECK(tipo IN(‘simple’,’doble’)),
Precio NUMBER(9));
2.
CREATE TABLE clientes (n_cliente NUMBER(4) CONSTRAINT pk_num_clie PRIMARY KEY,

nif NUMBER(8) CONSTRAINT uq_nif UNIQUE,
nombre_cliente varchar2(90),
nvisa NUMBER(4),
telefóno NUMBER(9));
3.
CREATE TABLE reservas( n_reservas NUMBER CONSTRAINT pk_reservas PRIMARY KEY,

n_cliente NUMBER(4)CONSTRAINT fk_client REFERENCES
clientes(n_cliente) ON DELETE CASCADE,
num_hab NUMBER(2) CONSTRAINT fk_numh REFERENCES
habitaciones(num_hab)ON DELETE CASCADE,
pagado char(2) CONSTRAINT ck_pagado CHECK
(pagado IN(‘s’,’n’)));
UTILIZACIÓN DE LA TABLA DE EXCEPCIONES

1.
ALTER TABLE clientes

DISABLE PRIMARY KEY CASCADE;
2.
INSERT INTO clientes values(1,’3456755’,’Jose Garcia’,9959,695356778);
3.
CREATE TABLE exceptions (

row_id ROWID,
owner VARCHAR2(30),
table_name VARCHAR2(30),
CONSTRAINT VARCHAR2(30));
4.

ENABLE CONSTRAINT pk_num_clie
5.
SELECT * FROM exceptions WHERE CONSTRAINT = 'PK_NUM_CLIE';
SELECT * FROM clientes WHERE ROWID= ‘ ‘ -- rowid de la busqueda anterior
UPDATE clients SET n_cliente = /*con este update modificar el

numero de cliente duplicado.*/
6.

ENABLE CONSTRAINT pk_num_clie;

Sql-Oracle 10G

Cargado por

Copyright:

Formatos disponibles

Sql-Oracle 10G

Cargado por

Información del documento

Título original

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

Sql-Oracle 10G

Cargado por

Copyright:

Formatos disponibles

ORACLE10G.

Capítulo 1. Introducción a SQL

Introducción al lenguaje SQL ........................................................................................1-1

Capítulo 2. Lenguaje de manipulación de datos. DML

Capítulo 3. El Lenguaje de definición de datos. DDL

ANEXO A. El interfaz de usuario SQL*PLUS

Introducción ................................................................................................................... A-1

ANEXO B. El interfaz de usuario iSQL*PLUS

Utlización de iSQL*Plus ................................................................................................ B-1

ANEXO C. Nuevas Funcionalidades Oracle10g

Introducción ................................................................................................................... C-1

Introducción ................................................................................................................... D-1

Ejercicios Lenguaje SQL

Modelo de datos ................................................................................................................1

Introducción al lenguaje SQL ........................................................................................... 1

INTRODUCCIÓN AL LENGUAJE SQL

SQL (Structured Query Language) es un lenguaje utilizado para el acceso y la

ESTÁNDARES SQL. SQL: 99

FUNCIONAMIENTO DEL LENGUAJE SQL

COMPONENTES DEL LENGUAJE SQL

DDL (DATA DEFINITION LANGUAJE - LENGUAJE DE DEFINICIÓN DE DATOS)

DML (DATA MANIPULATION LANGUAJE - LENGUAJE DE MANIPULACIÓN DE DATOS)

OBJETOS DE BASE DE DATOS

OBJETOS NO PERTENECIENTES A ESQUEMAS

REGLAS PARA NOMBRAR OBJETOS DE BASE DE DATOS

REFERENCIAR OBJETOS DE LA BASE DE DATOS

[esquema.]nombre_objeto[.parte objeto][@enlace base de datos]

En este caso el usuario conectado a la base de datos es usuario1, esta accediendo a un

Si el acceso se realiza a más de un objeto, es necesario anteponer el nombre del objeto

SELECT employees.department_id, departments.department_id

SELECT e. department_id departamento, d. department_id n_departamento

El alias dado a una columna, aparece como encabezado en el resultado de la consulta.

RESOLUCIÓN DE REFERENCIAS A OBJETOS

TIPOS DE DATOS EN ORACLE10G

Tipo de dato Descripción

Tipo de dato Descripción

INTERVAL DAY Almacena un periodo de tiempo en días, minutos y segundos.

Tipo de dato Descripción

EL DML (Data Manipulation Lenguage) es un sublenguaje de consulta y manipulación de

SELECT [ALL|DISTINCT] {Lista_Columnas_o_Expresiones | * }

• Lista_Columnas_o_Expresiones  Enumerar cada una de las columnas a

SELECCIÓN DE TODOS LOS DATOS DE UNA TABLA

Para seleccionar todos los datos de una tabla se utiliza el signo *.

SQL> DESC jobs

JOB_ID JOB_TITLE MIN_SALARY MAX_SALARY

También se pueden especificar todas las columnas en la lista de columnas de la sentencia

SQL> SELECT job_title Trabajo, job_id Abrev, min_salary salario_minimo,

TRABAJO ABREV SALARIO_MINIMO SALARIO_MAXIMO

SELECCIÓN DE CIERTAS COLUMNAS DE UNA TABLA

SQL> SELECT job_id, job_title

SQL> SELECT * FROM usu1.regions;

En el caso en el que los datos obtenidos provengan de varias tablas es conveniente

SQL> SELECT regions.region_id, regions.region_name, countries.country_name

REGION_ID REGION_NAME COUNTRY_NAME

SQL> SELECT R.region_id, R.region_name, C.country_name

REGION_ID REGION_NAME COUNTRY_NAME

SQL> SELECT * FROM countries

SQL> SELECT * FROM employees

Ejemplo Seleccionar todos los empleados ordenando el resultado por nombres