Sei sulla pagina 1di 119

MANUAL DE SQL

MANUAL DE SQL

Sql_manual.doc 1
MANUAL DE SQL

ÍNDICE

1 Introducción ......................................................................................................................... 5
2 Elementos de Oracle8 SQL ................................................................................................. 6
2.1 LITERALES......................................................................................................................... 6
2.2 TEXTO .............................................................................................................................. 6
2.3 ENTEROS .......................................................................................................................... 6
2.4 NUMÉRICOS ...................................................................................................................... 6
2.5 TIPOS DE DATOS ................................................................................................................ 7
2.5.1Tipos de datos CHARACTER .............................................................................................................. 7
2.5.2Tipo de datos NUMBER....................................................................................................................... 9
2.5.3Tipo de datos LONG .......................................................................................................................... 10
2.5.4Tipo de datos DATE........................................................................................................................... 11
2.5.5Tipos de datos RAW y LONG RAW................................................................................................... 11
2.5.6Tipo de datos LOB ............................................................................................................................. 12
2.5.7Tipo de datos ROWID ........................................................................................................................ 12
2.5.8Tipos de datos ANSI, DB2 y SQL/DS ................................................................................................ 12
2.5.9Conversión de datos .......................................................................................................................... 13
2.6 NULOS ............................................................................................................................ 15
2.6.1 Nulos en funciones SQL .................................................................................................................... 15
2.6.2 Nulos con los operadores de comparación........................................................................................ 15
2.6.3 Nulos en condiciones ......................................................................................................................... 15
2.7 PSEUDOCOLUMNAS .......................................................................................................... 16
2.7.1 CURRVAL y NEXTVAL...................................................................................................................... 16
2.7.2 ROWID............................................................................................................................................... 18
2.7.3 ROWNUM .......................................................................................................................................... 18
2.8 COMENTARIOS ................................................................................................................. 19
2.8.1 Comentarios en órdenes SQL ........................................................................................................... 19
2.8.2 Hints ................................................................................................................................................... 20
2.9 OBJETOS DE LA BASE DE DATOS ........................................................................................ 23
2.9.1 Objetos estructurados ........................................................................................................................ 23
2.9.2 Objetos no estructurados ................................................................................................................... 23
2.9.3 Partes de los objetos estructurados................................................................................................... 23
2.10 REFERENCIA A LOS OBJETOS ESTRUCTURADOS .................................................................. 24
2.10.1 Como resuelve Oracle la referencia a objetos estructurados ............................................................ 25
2.10.2 Referencias a objetos en otros esquemas......................................................................................... 26
2.10.3 Referencias a objetos en otras bases de datos ................................................................................. 26
3 Operadores, funciones y condiciones ............................................................................ 28
3.1 OPERADORES .................................................................................................................. 28
3.1.1 Operadores binarios y unitarios ......................................................................................................... 28
3.1.2 Preferencia......................................................................................................................................... 28
3.1.3 Operadores aritméticos...................................................................................................................... 29
3.1.4 Operador de concatenación .............................................................................................................. 29
3.1.5 Operadores de comparación ............................................................................................................. 30
3.1.6 Operador NOT IN............................................................................................................................... 31
3.1.7 Operador LIKE ................................................................................................................................... 31
3.1.8 Operadores lógicos ............................................................................................................................ 33
3.1.9 Operadores Set ................................................................................................................................. 34
3.1.10 Otros operadores ............................................................................................................................... 36

3.2 FUNCIONES SQL ............................................................................................................. 36


3.2.1 Funciones numéricas ......................................................................................................................... 37

Sql_manual.doc 2
MANUAL DE SQL

3.2.2 Funciones de caracteres.................................................................................................................... 42


3.2.3 Funciones de fecha (DATE)............................................................................................................... 48
3.2.4 Funciones de conversión ................................................................................................................... 51
3.2.5 Otras funciones .................................................................................................................................. 54
3.2.6 Funciones agrupadas ........................................................................................................................ 58
4 Comandos .......................................................................................................................... 61
4.1 COMANDOS DDL (DATA DEFINITION LANGUAJE) ................................................................ 61
4.1.1 ALTER CLUSTER.............................................................................................................................. 61
4.1.2 ALTER DATABASE ........................................................................................................................... 62
4.1.3 ALTER FUNCTION ............................................................................................................................ 62
4.1.4 ALTER INDEX ................................................................................................................................... 63
4.1.5 ALTER PACKAGE ............................................................................................................................. 64
4.1.6 ALTER PROCEDURE ....................................................................................................................... 64
4.1.7 ALTER ROLE..................................................................................................................................... 64
4.1.8 ALTER ROLLBACK SEGMENT ........................................................................................................ 64
4.1.9 ALTER SEQUENCE .......................................................................................................................... 65
4.1.10 ALTER TABLE ................................................................................................................................... 65
4.1.11 ALTER TABLESPACE ....................................................................................................................... 68
4.1.12 ALTER TRIGGER .............................................................................................................................. 68
4.1.13 ALTER TYPE ..................................................................................................................................... 69
4.1.14 ALTER USER .................................................................................................................................... 70
4.1.15 ALTER VIEW ..................................................................................................................................... 70
4.1.16 ANALYZE........................................................................................................................................... 71
4.1.17 COMMENT ........................................................................................................................................ 71
4.1.18 Cláusula CONSTRAINT..................................................................................................................... 71
4.1.19 CREATE CLUSTER........................................................................................................................... 76
4.1.20 CREATE CONTROLFILE .................................................................................................................. 77
4.1.21 CREATE DATABASE ........................................................................................................................ 78
4.1.22 CREATE FUNCTION ......................................................................................................................... 78
4.1.23 CREATE INDEX ................................................................................................................................ 79
4.1.24 CREATE PACKAGE .......................................................................................................................... 80
4.1.25 CREATE PACKAGE BODY ............................................................................................................... 81
4.1.26 CREATE PROCEDURE .................................................................................................................... 82
4.1.27 CREATE ROLE.................................................................................................................................. 83
4.1.28 CREATE ROLLBACK SEGMENT ..................................................................................................... 83
4.1.29 CREATE SCHEMA ............................................................................................................................ 83
4.1.30 CREATE SEQUENCE ....................................................................................................................... 84
4.1.31 CREATE SYNONYM ......................................................................................................................... 84
4.1.32 CREATE TABLE ................................................................................................................................ 85
4.1.33 CREATE TABLESPACE .................................................................................................................... 86
4.1.34 CREATE TRIGGER ........................................................................................................................... 87
4.1.35 CREATE TYPE .................................................................................................................................. 89
4.1.36 CREATE TYPE BODY ....................................................................................................................... 89
4.1.37 CREATE USER ................................................................................................................................. 90
4.1.38 CREATE VIEW .................................................................................................................................. 91
4.1.39 Cláusula DISABLE ............................................................................................................................. 92

4.1.40 Cláusula DROP.................................................................................................................................. 93


4.1.41 DROP CLUSTER ............................................................................................................................... 93
4.1.42 DROP DATABASE LINK ................................................................................................................... 93
4.1.43 DROP FUNCTION ............................................................................................................................. 94
4.1.44 DROP INDEX..................................................................................................................................... 94

Sql_manual.doc 3
MANUAL DE SQL

4.1.45
DROP PACKAGE .............................................................................................................................. 94
4.1.46
DROP ROLE ...................................................................................................................................... 94
4.1.47
DROP ROLLBACK SEGMENT.......................................................................................................... 95
4.1.48
DROP SEQUENCE ........................................................................................................................... 95
4.1.49
DROP SYNONYM ............................................................................................................................. 95
4.1.50
DROP TABLE .................................................................................................................................... 95
4.1.51
DROP TABLESPACE ........................................................................................................................ 96
4.1.52
DROP TRIGGER ............................................................................................................................... 96
4.1.53
DROP TYPE ...................................................................................................................................... 96
4.1.54
DROP TYPE BODY ........................................................................................................................... 96
4.1.55
DROP USER...................................................................................................................................... 97
4.1.56
DROP VIEW ...................................................................................................................................... 97
4.1.57
Cláusula ENABLE .............................................................................................................................. 97
4.1.58
GRANT (privilegios del sistema y roles) ............................................................................................ 98
4.1.59
GRANT (privilegios a objetos) ........................................................................................................... 98
4.1.60
RENAME............................................................................................................................................ 99
4.1.61
REVOKE (privilegios del sistema y roles) .......................................................................................... 99
4.1.62
REVOKE (privilegios de objetos) ....................................................................................................... 99
4.1.63
SUBQUERIES ................................................................................................................................. 100
4.2 COMANDOS DML (DATA MANIPULATION LANGUAGE) ........................................................ 101
4.2.1 DELETE ........................................................................................................................................... 102
4.2.2 EXPLAIN PLAN ............................................................................................................................... 102
4.2.3 INSERT ............................................................................................................................................ 103
4.2.4 SELECT ........................................................................................................................................... 104
4.2.5 UPDATE .......................................................................................................................................... 114
4.3 COMANDOS DE CONTROL DE LA TRANSACCIÓN ................................................................. 114
4.3.1 COMMIT .......................................................................................................................................... 115
4.3.2 ROLLBACK ...................................................................................................................................... 115
4.3.3 SAVEPOINT .................................................................................................................................... 115
4.4 COMANDOS DE CONTROL DE LA SESIÓN ........................................................................... 116
4.4.1 ALTER SESSION ............................................................................................................................ 116
4.4.2 SET ROLE ....................................................................................................................................... 117
4.5 COMANDO DE CONTROL DEL SISTEMA .............................................................................. 118
4.5.1 ALTER SYSTEM.............................................................................................................................. 118

Sql_manual.doc 4
MANUAL DE SQL

1 Introducción

SQL es un conjunto de comandos que todos los programas y todos los usuarios deben utilizar para
acceder a los datos de una base de datos Oracle. Algunas aplicaciones y herramientas de Oracle
permiten al usuario acceder a la base de datos sin usar directamente SQL, aunque dichas herramientas
necesitan SQL para comunicarse con la base de datos.

Técnicamente hablando, es un sublenguaje de datos: el propósito de SQL es proveer de una


interfaz a una base de datos relacional, como puede ser Oracle. Todos los estamentos de SQL son
instrucciones para la base de datos.

SQL provee comandos para una gran cantidad de tareas, como pueden ser:

Consultas de datos.
Inserción, modificación y borrado de columnas en una tabla.
Creación, reemplazo, modificación y borrado de objetos.
Control del acceso a la base de datos.
Garantizar la consistencia y la integridad en la base de datos.

Sql_manual.doc 5
MANUAL DE SQL

2 Elementos de Oracle8 SQL

Este capítulo contiene información referente a los elementos básicos de Oracle SQL.

2.1 Literales

Los términos literal y constante son sinónimos y se refieren a un valor de datos fijo. Por ejemplo,
‘JACK’, ‘BLUE ISLAND’ y ‘101’ son literales de carácter, y 5001 es un literal numérico. Los literales de
carácter se deben escribir entre comillas simples para distinguirlos de los nombres de los objetos de
Oracle.

2.2 Texto

Texto especifica un texto o un literal de carácter. Se debe usar esta notación para especificar
valores texto o char que aparecen en expresiones, condiciones, funciones SQL y comandos SQL. Tanto
el literal de texto como el de carácter deben ser escritos entre comillas simples.

Los literales de texto tienen propiedades de los tipos de datos CHAR y VARCHAR2.

Los siguientes ejemplos son literales de texto válidos:

'Hello'
'ORACLE.dbs'
'Jackie''s raincoat'
'09-MAR-92'
N'nchar literal'

2.3 Enteros

Se debe usar la notación de entero para especificar un entero siempre que aparezca en
expresiones, condiciones, funciones y comandos SQL.

Un entero puede almacenar un máximo de 38 dígitos de precisión.

Los siguientes ejemplos son enteros válidos:

7, +255

2.4 Numéricos

Se debe utilizar la notación numérica para especificar los valores numéricos, siempre que
aparezcan en expresiones, condiciones, funciones y comandos SQL.
Un número puede almacenar un máximo de 38 dígitos de precisión.

Los siguientes ejemplos son números válidos:


25, +6.34, 0.5, 25e-03, -1

Sql_manual.doc 6
MANUAL DE SQL

2.5 Tipos de datos

Cada valor de columna o literal manipulado por Oracle tiene un tipo de dato. Cuando creas una
tabla, debes especificar un tipo de dato interno para cada una de sus columnas. Cuando creas una
función o un procedimiento almacenado, debes especificar un tipo de dato interno para cada uno de sus
parámetros. Estos tipos de datos definen el dominio de los valores que cada columna puede contener o
que cada argumento puede tener.

Tabla 2.1 Tipos de datos internos de Oracle.

Código Tipo de dato Descripción

VARCHAR2 Variable-length character string having maximum length size bytes. Maximum size is
1
(size) 4000, and minimum is 1. You must specify size for a VARCHAR2.
Variable-length character string having maximum length size characters or bytes,
NVARCHAR2 depending on the choice of national character set. Maximum size is determined by the
(size) number of bytes required to store each character, with an upper limit of 4000 bytes.
You must specify size for NVARCHAR2.
Number having precision p and scale s. The precision p can range from 1 to 38. The
2 NUMBER(p,s)
scale s can range from -84 to 127.
8 LONG Character data of variable length up to 2 gigabytes, or 231 -1 bytes.
12 DATE Valid date range from January 1, 4712 BC to December 31, 4712 AD.
Raw binary data of length size bytes. Maximum size is 2000 bytes. You must specify
23 RAW(size)
size for a RAW value.
24 LONG RAW Raw binary data of variable length up to 2 gigabytes.
Hexadecimal string representing the unique address of a row in its table. This
69 ROWID datatype is primarily for values returned by the ROWID pseudocolumn.

Fixed length character data of length size bytes. Maximum size is 2000 bytes. Default
96 CHAR(size)
and minimum size is 1 byte.
Fixed-length character data of length size characters or bytes, depending on the
choice of national character set. Maximum size is determined by the number of bytes
NCHAR(size)
required to store each character, with an upper limit of 2000 bytes. Default and
minimum size is 1 character or 1 byte, depending on the character set.
Binary format of an operating system label. This datatype is used for backward
106 MLSLABEL
compatibility with Trusted Oracle.
A character large object containing single-byte characters. Variable-width character
112 CLOB
sets are not supported. Maximum size is 4 gigabytes.
A character large object containing fixed-width multibyte characters. Variable-width
NCLOB character sets are not supported. Maximum size is 4 gigabytes. Stores national
character set data.
113 BLOB A binary large object. Maximum size is 4 gigabytes.
Contains a locator to a large binary file stored outside the database. Enables byte
114 BFILE stream I/O access to external LOBs residing on the database server. Maximum size is
4 gigabytes.

2.5.1 Tipos de datos CHARACTER

Sql_manual.doc 7
MANUAL DE SQL

Los tipos de datos carácter almacenan caracteres alfanuméricos. Son poco restrictivos, por lo
que tienen pocas propiedades. Los datos de tipo carácter se almacenan en strings de un byte.

Los tipos de datos que se utilizan para los caracteres son los siguientes:

Tipo de datos CHAR.


Tipo de datos NCHAR.
Tipo de datos NVARCHAR2.
Tipo de datos VARCHAR2.

2.5.1.1 Tipo de datos CHAR

Especifica un string de tamaño fijo. El tamaño viene especificado en bytes. Cuando en una tabla
creamos una columna de tipo CHAR con un tamaño determinado, e insertamos un valor de menor
tamaño que el especificado en la columna, se rellena el espacio sobrante de espacios en blanco, y si
introducimos un carácter de tamaño mayor al tamaño especificado de la columna, Oracle devuelve un
error.

El tamaño por defecto de CHAR es un carácter, y el tamaño máximo permitido es de 2000


caracteres.

2.5.1.2 Tipo de datos NCHAR

Especifica un string de tamaño fijo que se rige según el conjunto nacional de caracteres, debido
a esto el tamaño del string puede venir especificado en bytes o en caracteres, según se haya definido el
conjunto nacional de caracteres cuando se creo la base de datos.

El tamaño máximo de cada columna de este tipo viene determinado por el conjunto nacional de
caracteres. Generalmente no suele permitir más de 2000 caracteres.

A la hora de insertar datos se comporta de igual manera que CHAR. No se puede introducir un
valor CHAR en una columna definida como NCHAR, y viceversa.

2.5.1.3 Tipo de datos NVARCHAR2

Especifica un string de tamaño variable que se rige según el conjunto nacional de caracteres. Al
crear una columna de este tipo en una tabla, se especifica el tamaño máximo que puede soportar en
bytes o en caracteres.

Si insertamos un carácter en una columna de este tipo con tamaño menor que el definido por la
columna, dicho carácter solo ocupa en disco su tamaño, no el tamaño que tiene definido la columna. La
diferencia que tiene con el tipo de datos NCHAR es que no rellena el espacio sobrante con blancos.

2.5.1.4 Tipo de datos VARCHAR2

Sql_manual.doc 8
MANUAL DE SQL

Especifica un string de tamaño variable. Cuando creamos una columna de este tipo,
especificamos el máximo número de bytes de datos que cada registro de la columna puede contener. Al
igual que el tipo de datos NVARCHAR2, si introducimos un valor menor que el tamaño de la columna, en
disco solo se ocupa el tamaño del valor que hayamos introducido. Si introducimos un valor mayor que el
que tiene la columna, Oracle nos devuelve un error.

El tamaño por defecto de este tipo de datos es un byte, y el tamaño máximo que permite es de
4000 bytes.

2.5.1.5 Tipo de datos VARCHAR

Es sinónimo del tipo de datos VARCHAR2, pero es recomendable utilizar este último.

2.5.2 Tiipo de datos NUMBER

Este tipo de datos almacena cero, números positivos y negativos fijos y números en punto
flotante con magnitudes comprendidas entre 1.0 x 10e –130 y 9.9 x 10e 125, con 38 dígitos de precisión.
Tiene la siguiente sintaxis:
NUMBER (p, s)

Donde s es la escala, con un rango de –84 a 127 y p es la precisión (38).

2.5.2.1 Escala y precisión

Los siguientes ejemplos muestran como Oracle almacena datos usando diferentes escalas y
precisiones.

7456123.89 NUMBER 7456123.89


7456123.89 NUMBER(9) 7456124
7456123.89 NUMBER(9,2) 7456123.89
7456123.89 NUMBER(9,1) 7456123.9
7456123.89 NUMBER(6) Excede la precisión
7456123.89 NUMBER(7,-2) 7456100
7456123.89 NUMBER(-7,2) Excede la precisión

2.5.2.2 Escala negativa

Si la escala es negativa, el dato es redondeado el número especificado de lugares a la izquierda


del punto decimal.

2.5.2.3 Mayor escala que precisión

Sql_manual.doc 9
MANUAL DE SQL

Se puede especificar una escala mayor que la precisión, aunque no es muy común. En este caso
la precisión especifica el máximo número de dígitos a la derecha del punto decimal. Los siguientes
ejemplos muestran los efectos de una escala mayor que la precisión:

Dato actual Especificado como Almacenado como


.01234 NUMBER(4,5) .01234
.00012 NUMBER(4,5) .00012
.000127 NUMBER(4,5) .00013
.0000012 NUMBER(2,7) .0000012
.00000123 NUMBER(2,7) .0000012

2.5.2.4 Números en punto flotante

El número pueden tener un punto decimal en cualquier lugar, o pueden no tener ninguno. No se
les puede asignar ningún valor de escala.

Oracle también soporta el tipo de datos ANSI FLOAT. Se puede especificar este tipo de dato
siguiendo una de las siguientes formas sintácticas:

FLOAT specifies a floating-point number with decimal precision 38, or binary precision 126.
specifies a floating-point number with binary precision b. The precision b can range from 1 to 126. To
FLOAT(b) convert from binary to decimal precision, multiply b by 0.30103. To convert from decimal to binary
precision, multiply the decimal precision by 3.32193. The maximum of 126 digits of binary precision is
roughly equivalent to 38 digits of decimal precision.

2.5.3 Tipo de datos LONG

Las columnas de tipo LONG almacenan strings de tamaño variable con un tamaño máximo de 2
gigabytes. Se pueden usar las columnas de tipo LONG para almacenar strings de gran tamaño. Oracle
utiliza las columnas de tipo LONG en el diccionario de datos para almacenar las definiciones de texto o
de vista.

Se pueden referenciar columnas LONG en las siguientes partes de una orden SQL:

Listas SELECT.
Cláusula SET de la orden UPDATE.
Cláusula VALUES de la orden INSERT.

El uso de los valores LONG está sujeto a algunas restricciones:

Una tabla no puede contener más de una columna LONG.


Las columnas LONG no pueden aparecer en constraints de integridad.
Las columnas LONG no pueden ser indexadas.
Una función almacenada no puede devolver un valor LONG.

Las columnas LONG no pueden aparecer en ciertas partes de una orden SQL:

Sql_manual.doc 10
MANUAL DE SQL

En las cláusulas WHERE, GROUP BY, ORDER BY y CONNECT BY o con el operador


DISTINCT en una orden SELECT.
La cláusula UNIQUE en una orden SELECT.
La cláusula CLUSTER en una orden CREATE SNAPSHOT.

Los disparadores pueden utilizar el tipo de datos LONG de la siguiente manera:

:NEW y :OLD no pueden ser usados con columnas de tipo LONG.


Las variables en los disparadores no pueden ser creadas usando el tipo de datos LONG.
Una orden SQL dentro de un disparador, puede insertar datos en una columna de tipo
LONG.

2.5.4 Tipo de datos DATE

Los datos de tipo DATE almacenan información de fecha y de tiempo. La información de fecha y
de tiempo también puede ser almacenada con los tipos de datos CHAR y NUMBER. Para cada valor
DATE, Oracle almacena la siguiente información: centuria, año, mes, día, hora, minuto y segundo.

Para especificar un valor de tipo DATE, se debe convertir un valor numérico o de tipo carácter a
un valor de tipo DATE mediante la función TO_DATE. El formato por defecto de DATE, es especificado
en el parámetro NLS_DATE_FORMAT y es un string del tipo ‘DD-MON-YY’.

Si se especifica un valor de tipo DATE sin el componente de tiempo, el tiempo por defecto son
las 12:00:00 a.m. (medianoche). Si se especifica un valor de tipo DATE, sin el componente de fecha, la
fecha por defecto es el primer día del mes actual.

2.5.4.1 Uso de fechas julianas

Una fecha juliana es el número de días desde el 1 de Enero del 4712 a.c. Se puede usar el
modelo de formato “J” con las funciones TO_DATE y TO_CHAR para convertir valores de tipo DATE a
sus equivalentes en fecha juliana.

Ejemplo

SELECT TO_CHAR(TO_DATE('01-01-1997', 'MM-DD-YYYY'),'J')


FROM DUAL;

TO_CHAR
--------
2450450

2.5.5 Tipos de datos RAW y LONG RAW

Estos tipos de datos almacenan datos que no van a ser interpretados por Oracle. Por ejemplo, se
puede usar el tipo LONG RAW para almacenar gráficos, sonido, documentos; la interpretación depende
de su uso.

Sql_manual.doc 11
MANUAL DE SQL

RAW es un tipo de datos de tamaño variable similar al tipo de datos VARCHAR2, la diferencia es
que tanto Net8 como las utilidades EXPORT e IMPORT no depuran la conversión del carácter cuando
transmiten datos de tipo RAW o LONG RAW.

Se puede indexar un dato de tipo RAW pero no un dato de tipo LONG RAW.

2.5.6 Tipo de datos LOB

Los tipos de datos LOB internos (BLOB, CLOB y NCLOB) y externos (BFILE), pueden almacenar
datos que no están estructurados y son de gran tamaño, como texto, imagen y vídeo, hasta un tamaño
máximo de 4 gigabytes.

Las columnas de tipo LOB interno, contienen localizadores LOB que pueden referenciar valores
LOB en línea o fuera de línea. Si se selecciona un LOB de una tabla, lo que nos devuelve Oracle es el
localizador de LOB, no el valor de tipo LOB.

El siguiente ejemplo crea una tabla con columnas LOB.

CREATE TABLE person_table (name CHAR(40),


resume CLOB,
picture BLOB)
LOB (resume) STORE AS
( TABLESPACE resumes
STORAGE (INITIAL 5M NEXT 5M) );

2.5.6.1 Tipo de datos BFILE

Permite el acceso a ficheros binarios LOB que se encuentran almacenados en ficheros de


sistema fuera de la base de datos Oracle.

El tipo de datos BFILE permite la lectura (read-only) de ficheros binarios de gran tamaño. Oracle
provee APIs para acceder a los ficheros de datos.

2.5.7 Tipo de datos ROWID

Cada registro en una base de datos tiene una dirección. Se puede examinar la dirección de un
registro mediante una consulta a la pseudocolumna ROWID. Los valores de esta pseudocolumna son
strings hexadecimales que representan la dirección de cada registro.

2.5.8 Tipos de datos ANSI, DB2 y SQL/DS

Oracle reconoce los tipos de datos de ANSI y de DB2, y los convierte automáticamente a los
tipos de datos propios de Oracle.

Sql_manual.doc 12
MANUAL DE SQL

Tabla 2.2 Tipos de datos ANSI convertidos a tipos de datos Oracle.

Tipo de datos ANSI SQL Tipo de datos Oracle


CHARACTER(n)
CHAR(n)
CHAR(n)
CHARACTER VARYING(n)
VARCHAR(n)
CHAR VARYING(n)
NATIONAL CHARACTER(n)
NATIONAL CHAR(n) NCHAR(n)
NCHAR(n)
NATIONAL CHARACTER VARYING(n)
NATIONAL CHAR VARYING(n) NVARCHAR2(n)
NCHAR VARYING(n)
NUMERIC(p,s)
NUMBER(p,s)
DECIMAL(p,s)a
INTEGER
INT NUMBER(38)
SMALLINT
FLOAT(b)b
DOUBLE PRECISIONc NUMBER
REALd

Tabla 2.3 Tipos de datos DB2 y SQL/DS convertidos a tipos de datos Oracle

Tipos de datos SQL/DS o DB2 Tipos de datos Oracle


CHARACTER(n) CHAR(n)
VARCHAR(n) VARCHAR(n)
LONG VARCHAR(n) LONG
DECIMAL(p,s)a NUMBER(p,s)
INTEGER
NUMBER(38)
SMALLINT
FLOAT(b)b NUMBER

2.5.9 Conversión de datos

Generalmente una expresión no puede contener valores de diferentes tipos de datos. Oracle
soporta la conversión de datos implícita y explícita.

2.5.9.1 Conversión de datos Implícita

Sql_manual.doc 13
MANUAL DE SQL

Oracle convierte automáticamente un valor de un tipo de datos a otro. Realiza este tipo de
conversión en los siguientes casos:

Cuando una orden INSERT o UPDATE asigna un valor de un tipo de datos a una columna
que tiene definido otro tipo de datos.
Cuando se usa una función SQL o un operador, y el argumento que se le pasa es un tipo de
datos distinto al que tiene definido la función o el operador.
Cuando se utiliza un operador de comparación con valores que tienen distintos tipos de
datos.

Ejemplo 1

El literal de texto ‘10’ es de tipo CHAR. Oracle lo convierte implícitamente a un tipo NUMBER si
aparece en una expresión numérica, como la siguiente:

SELECT sal + '10'


FROM emp;

Ejemplo 2

Cuando una condición compara un valor de tipo CHARACTER con uno de tipo NUMBER, Oracle
convierte el valor de tipo CHARACTER a un valor de tipo NUMBER.

SELECT ename
FROM emp
WHERE empno = '7936';

Ejemplo 3

En la orden siguiente, Oracle convierte ‘12-MAR-1993’ a un valor de tipo DATE utilizando el


formato por defecto de DATE ‘DD-MON-YYYY’:

SELECT ename
FROM emp
WHERE hiredate = '12-MAR-1993';

2.5.9.2 Conversión de datos Explícita

También se puede especificar el tipo de conversión de datos que se desea realizar utilizando las
funciones de conversión de SQL.

TO: FROM: CHAR NUMBER DATE RAW ROWID


CHAR - TO_NUMBER TO_DATE HEXTORAW CHARTOROWID
TO_DATE
NUMBER TO_CHAR -
(number,'J')
TO_CHAR
DATE TO_CHAR -
(date,'J')
RAW RAWTOHEX -
ROWID ROWIDTOCHAR -

Sql_manual.doc 14
MANUAL DE SQL

2.5.9.3 Conversión de datos Implícitos vs Explícitos

Oracle recomienda utilizar la conversión de datos explícita antes que la conversión de datos
implícita por las siguientes razones:

Las órdenes SQL son más sencillas de comprender cuando se utilizan las funciones de
conversión.
La conversión automática de tipos de datos puede tener un impacto negativo en la
depuración, especialmente cuando se convierte el tipo de datos de una columna.
La conversión implícita depende del contexto en el que ocurre y no puede trabajar usando el
mismo camino en todos los casos.
Los algoritmos para la conversión implícita están sujetos a los cambios de software que
puedan suceder.

2.6 Nulos

Si una columna de un registro no contiene ningún valor, se dice que la columna es nula o que
contiene un nulo. Los nulos pueden aparecer en todas las columnas que no estén restringidas por NOT
NULL o PRIMARY KEY.

No hay que usar un nulo para representar el valor cero, porque ambos no son equivalentes.
Cualquier expresión aritmética que contenga un nulo siempre será evaluada como nulo, por ejemplo, un
nulo añadido a 10 es un nulo.

2.6.1 Nulos en funciones SQL

Todas las funciones escalares (excepto NVL y TRANSLATE) devuelven nulo cuando se les pasa
un nulo. Muchos grupos de funciones ignoran los nulos, un ejemplo de ello es la función que realiza el
promedio, si se le pasa algún nulo no lo considera.

2.6.2 Nulos con los operadores de comparación

Para realizar comparaciones con los nulos, solo se deben utilizar los operadores de comparación
IS NULL e IS NOT NULL. Si se usa cualquier otro operador en una comparación en la que están
implicados nulos, el resultado será UNKNOWN. Sin embargo, Oracle considera que dos nulos son iguales
cuando se evalúan con la expresión DECODE.

2.6.3 Nulos en condiciones

Sql_manual.doc 15
MANUAL DE SQL

Tabla 2.4 Ejemplos de comparaciones con nulos

If A is: Condición Evaluado a:


10 a IS NULL FALSE
10 a IS NOT NULL TRUE
NULL a IS NULL TRUE
NULL a IS NOT NULL FALSE
10 a = NULL UNKNOWN
10 a != NULL UNKNOWN
NULL a = NULL UNKNOWN
NULL a != NULL UNKNOWN
NULL a = 10 UNKNOWN
NULL a != 10 UNKNOWN

2.7 Pseudocolumnas

Una pseudocolumna es similar a la columna de una tabla, pero no se almacena en la tabla. Se


puede realizar un SELECT de una pseudocolumna, pero no se puede utilizar las órdenes INSERT,
UPDATE o DELETE.

2.7.1 CURRVAL y NEXTVAL

Una secuencia es un objeto que puede generar valores secuenciales únicos. Estos valores a
menudo se usan como claves primarias y únicas. Se puede referir a los valores secuenciales en una
orden SQL mediante las siguientes pseudocolumnas:

CURRVAL Retorna el valor actual de la secuencia.


NEXTVAL Incrementa la secuencia y retorna el siguiente valor.

Para referirse a CURRVAL y NEXTVAL se debe utilizar el nombre de la secuencia.

Sequence.CURRVAL
Sequence.NEXTVAL

Para referirse al valor de una secuencia que se encuentra en una base de datos remota, se debe
referenciar la secuencia de la siguiente manera:

Schema.sequence.CURRVAL@dblink
Schema.sequence.NEXTVAL@dblink

2.7.1.1 Cuando utilizar los valores de secuencia

Se puede utilizar CURRVAL y NEXTVAL en los siguientes lugares:

Sql_manual.doc 16
MANUAL DE SQL

En una orden SELECT que no este contenida en una subconsulta o en una vista.
La cláusula VALUES en una orden INSERT.
La cláusula SET en una orden UPDATE.

No se puede utilizar CURRVAL y NEXTVAL en los siguientes lugares:

Una subconsulta en una orden DELETE, SELECT o UPDATE.


En una consulta de una vista.
En una orden SELECT con el operador DISTINCT.
En una orden SELECT con las cláusulas GROUP BY u ORDER BY.
En una orden SELECT que este combinada con otro SELECT mediante UNION,
INTERSECT o MINUS.
En la cláusula WHERE de una orden SELECT.
En el valor por defecto de una columna (DEFAULT) en las órdenes CREATE TABLE o
ALTER TABLE.

2.7.1.2 Como usar los valores de secuencia

Cuando creas una secuencia, puedes definir su valor inicial y el incremento entre los valores. La
primera referencia a NEXTVAL devuelve el valor inicial de la secuencia. Cualquier referencia a CURRVAL
devuelve el valor actual de la secuencia. Antes de utilizar CURRVAL en una secuencia se debe inicializar
la secuencia con NEXTVAL.

Ejemplo 1

Este ejemplo selecciona el valor actual de la secuencia employee:

SELECT empseq.currval
FROM DUAL;

Ejemplo 2

Este ejemplo incrementa la secuencia de employee y utiliza este valor para una inserción en la
tabla employee:

INSERT INTO emp


VALUES (empseq.nextval, 'LEWIS', 'CLERK', 7902, SYSDATE, 1200, NULL, 20);

Ejemplo 3

INSERT INTO master_order(orderno, customer, orderdate)


VALUES (orderseq.nextval, 'Al''s Auto Shop', SYSDATE);

INSERT INTO detail_order (orderno, part, quantity)


VALUES (orderseq.currval, 'SPARKPLUG', 4);

INSERT INTO detail_order (orderno, part, quantity)


VALUES (orderseq.currval, 'FUEL PUMP', 1);

Sql_manual.doc 17
MANUAL DE SQL

INSERT INTO detail_order (orderno, part, quantity)


VALUES (orderseq.currval, 'TAILPIPE', 2);

2.7.2 ROWID

Para cada registro de una base de datos, la pseudocolumna ROWID devuelve la dirección del
registro. Contiene la información necesaria para localizar un registro:

El número del objeto de datos del objeto.


En que bloque de datos del fichero de datos.
En que registro del bloque de datos.
En que fichero de datos.

Usualmente, un ROWID identifica a un único registro de la base de datos, aunque se pueden dar
algunos casos en que esto no ocurra.

Los valores ROWID tiene algunos usos importantes:

Son el camino más rápido para acceder a un único registro.


Pueden mostrar como están almacenados los registros de una tabla.
Son identificadores únicos de los registros de una tabla.

No se debe utilizar ROWID como la PRIMARY KEY de una tabla. Si borras o reinsertas un
registro con las utilidades Export e Import este ROWID podría cambiar. Si borramos un registro, Oracle
podría reasignar este ROWID a un nuevo registro insertado después.

Ejemplo

Esta orden SELECT consulta la dirección de todos los registros de la tabla emp cuyo
departamento sea 20:

SELECT ROWID, ename


FROM emp
WHERE deptno = 20;

ROWID ENAME
------------------ ----------
AAAAfSAABAAAClaAAA SMITH
AAAAfSAABAAAClaAAD JONES
AAAAfSAABAAAClaAAH SCOTT
AAAAfSAABAAAClaAAK ADAMS
AAAAfSAABAAAClaAAM FORD

2.7.3 ROWNUM
Para cada registro que retorna una consulta, la pseudocolumna ROWNUM retorna un número
indicando el orden en el cual Oracle selecciona los registros de una tabla.

Sql_manual.doc 18
MANUAL DE SQL

Se puede usar ROWNUM para limitar el número de registros que retorna una consulta, como en
el siguiente ejemplo:

SELECT *
FROM emp
WHERE ROWNUM < 10;

Oracle asigna un nuevo valor ROWNUM a cada registro después de que se realice una
ordenación con ORDER BY, por lo que ORDER BY normalmente no suele afectar al ROWNUM de cada
registro.

2.8 Comentarios

2.8.1 Comentarios en órdenes SQL

Los comentarios en las órdenes SQL no afectan a la ejecución de la orden, y pueden ayudar a la
hora de entender y mantener las órdenes.

Se puede incluir un comentario en una orden de las siguientes maneras:

Comenzando el comentario con /* y terminándolo con */. Estos comentarios pueden incluir
más de una línea.
Comenzando el comentario con --. Este tipo de comentarios solo pueden ocupar una línea.

Una orden SQL puede contener múltiples comentarios de ambos estilos.

Ejemplo

SELECT ename, sal + NVL(comm, 0), job, loc


/* Select all employees whose compensation is
greater than that of Jones.*/
FROM emp, dept
/*The DEPT table is used to get the department name.*/
WHERE emp.deptno = dept.deptno
AND sal + NVL(comm,0) > /* Subquery: */
(SELECT sal + NLV(comm,0)
/* total compensation is sal + comm */
FROM emp
WHERE ename = 'JONES')

SELECT ename, -- select the name


sal + NVL(comm, 0), -- total compensation
job, -- job
loc -- and city containing the office
FROM emp, -- of all employees
dept
WHERE emp.deptno = dept.deptno
AND sal + NVL(comm, 0) > -- whose compensation
-- is greater than

Sql_manual.doc 19
MANUAL DE SQL

(SELECT sal + NVL(comm,0) -- the compensation


FROM emp
WHERE ename = 'JONES') -- of Jones.

2.8.2 Hints

Se pueden usar los comentarios en órdenes SQL para pasar instrucciones o hints al optimizador
de Oracle. El optimizador utiliza estos hints para elegir el plan de ejecución de la orden.

A continuación se muestra la sintaxis para escribir hints en bloques de órdenes:

{DELETE|INSERT|SELECT|UPDATE} /*+ hint [text] [hint[text]]... */

{DELETE|INSERT|SELECT|UPDATE} --+ hint [text] [hint[text]]...

donde:

DELETE ,INSERT, is a DELETE, INSERT, SELECT, or UPDATE keyword that begins a statement block.
SELECT,UPDATE Comments containing hints can appear only after these keywords.
is a plus sign that causes Oracle to interpret the comment as a list of hints. The plus sign
+
must follow immediately after the comment delimiter (no space is permitted).
is one of the hints discussed in this section and in Oracle8 Tuning. The space between the
hint plus sign and the hint is optional. If the comment contains multiple hints, each pair of hints
must be separated by at least one space.
text is other commenting text that can be interspersed with the hints.

Tabla 2.5 Sintaxis y descripciones de Hint

Hint Syntax Description


Optimization Approaches and Goals
/*+ ALL_ROWS explicitly chooses the cost-based approach to optimize a statement block with a goal of best
*/ throughput (that is, minimum total resource consumption)
/*+ CHOOSE causes the optimizer to choose between the rule-based approach and the cost-based approach
for a SQL statement based on the presence of statistics for the tables accessed by the
*/
statement
/*+
FIRST_ROWS explicitly chooses the cost-based approach to optimize a statement block with a goal of best
*/ response time (minimum resource usage to return first row)
/*+ RULE */ explicitly chooses rule-based optimization for a statement block
Access Methods
/*+
AND_EQUAL(ta explicitly chooses an execution plan that uses an access path that merges the scans on several

Sql_manual.doc 20
MANUAL DE SQL

Hint Syntax Description


ble index) single-column indexes
*/
/*+
CLUSTER(tabl explicitly chooses a cluster scan to access the specified table
e) */
/*+
FULL(table) explicitly chooses a full table scan for the specified table
*/
/*+
HASH(table) explicitly chooses a hash scan to access the specified table
*/
/*+
HASH_AJ(tabl transforms a NOT IN subquery into a hash antijoin to access the specified table
e) */
/*+ HASH_SJ
transforms a NOT IN subquery into a hash anti-join to access the specified table
(table) */
/*+
INDEX(table explicitly chooses an index scan for the specified table
index) */
/*+
INDEX_ASC(ta
ble index) explicitly chooses an ascending-range index scan for the specified table
*/
/*+ If no indexes are given as arguments for the INDEX_COMBINE hint, the optimizer uses
INDEX_COMBIN whatever Boolean combination of bitmap indexes has the best cost estimate. If particular
E(table indexes are given as arguments, the optimizer tries to use some Boolean combination of those
index) */ particular bitmap indexes.
/*+
INDEX_DESC(t
able index) explicitly chooses a descending-range index scan for the specified table
*/
/*+
INDEX_FFS(ta
ble index) causes a fast full index scan to be performed rather than a full table scan
*/
/*+ MERGE_AJ
transforms a NOT IN subquery into a merge anti-join to access the specified table
(table) */
/*+ MERGE_SJ
transforms a correlated EXISTS subquery into a merge semi-join to access the specified table
(table) */
/*+
ROWID(table) explicitly chooses a table scan by ROWID for the specified table
*/
/*+
USE_CONCAT forces combined OR conditions in the WHERE clause of a query to be transformed into a
*/ compound query using the UNION ALL set operator
Join Orders
/*+ ORDERED
causes Oracle to join tables in the order in which they appear in the FROM clause
*/
/*+ STAR */ forces the large table to be joined last using a nested-loops join on the index
Join Operations
/*+ DRIVING_SITE
forces query execution to be done at a different site from that selected by Oracle
(table) */

Sql_manual.doc 21
MANUAL DE SQL

Hint Syntax Description


/*+ USE_HASH
causes Oracle to join each specified table with another row source with a hash join
(table) */
/*+
USE_MERGE causes Oracle to join each specified table with another row source with a sort-merge join
(table) */
/*+ USE_NL causes Oracle to join each specified table to another row source with a nested-loops join using
(table) */ the specified table as the inner table
Parallel Execution
/*+ APPEND
*/ specifies that data is simply appended (or not) to a table; existing free space is not used. Use
/*+ NOAPPEND these hints only following the INSERT keyword.
*/
/*+
NOPARALLEL(t disables parallel scanning of a table, even if the table was created with a PARALLEL clause
able) */
/*+ allows you to specify the desired number of concurrent slave processes that can be used for the
PARALLEL(tab operation.
le, DELETE, INSERT, and UPDATE operations are considered for parallelization only if the
instances) session is in a PARALLEL DML enabled mode. (Use ALTER SESSION PARALLEL DML to
*/ enter this mode.)
/*+
PARALLEL_IND allows you to parallelize fast full index scan for partitioned and nonpartitioned indexes that have
EX the PARALLEL attribute
/*+
NOPARALLEL_IN overrides a PARALLEL attribute setting on an index
DEX */
Other Hints
specifies that the blocks retrieved for the table in the hint are placed at the most recently used
/*+ CACHE */
end of the LRU list in the buffer cache when a full table scan is performed
/*+ NOCACHE specifies that the blocks retrieved for this table are placed at the least recently used end of the
*/ LRU list in the buffer cache when a full table scan is performed
/*+ MERGE (table)
causes Oracle to evaluate complex views or subqueries before the surrounding query
*/
/*+ NO_MERGE
causes Oracle not to merge mergeable views
(table) */
/*+
causes the optimizer to evaluate, on a cost basis, whether or not to push individual join
PUSH_JOIN_PRE
predicates into the view
D (table) */
/*+
NO_PUSH_JOIN_ Prevents pushing of a join predicate into the view
PRED (table) */
/*+ causes nonmerged subqueries to be evaluated at the earliest possible place in the execution
PUSH_SUBQ */ plan
/*+
STAR_TRANSFO makes the optimizer use the best plan in which the transformation has been used.
RMATION */

Sql_manual.doc 22
MANUAL DE SQL

2.9 Objetos de la base de datos

2.9.1 Objetos estructurados

Un esquema o estructura es una colección de estructuras lógicas de datos. Cada usuario tiene
su propio esquema simple. Los objetos estructurados pueden ser creados y manipulados con SQL, e
incluye los siguientes tipos de objetos:

Clusters.
Enlaces de base de datos.
Disparadores (triggers).
Librerías externas de procedimientos.
Tablas con un único índice.
Índices.
Paquetes.
Secuencias.
Funciones almacenadas.
Procedimientos almacenados.
Sinónimos.
Tablas.
Vistas.

Los siguientes objetos estructurados están permitidos si se está utilizando la funcionalidad


distribuida de Oracle:

Snapshots.
Snapshot log.

2.9.2 Objetos no estructurados

Otros tipos de objetos están almacenados en la base de datos y pueden ser manipulados con
SQL, pero no son estructurados, son los siguientes:
Directorios.
Reglas.
Segmentos de rehacer.
Espacio de tablas.
Usuarios.

2.9.3 Partes de los objetos estructurados

2.9.3.1 Tablas particionadas e índices

Sql_manual.doc 23
MANUAL DE SQL

Las tablas y los índices pueden estar en varias partes. Cuando realizamos una partición, estos
objetos consisten en un número de partes llamadas particiones, y todas ellas tienen los mismos atributos.
Por ejemplo, todas las particiones en una tabla comparten la misma columna y las mismas definiciones.

2.9.3.2 Nombres de tablas particionadas

Las particiones pueden ser usadas como tablas. Para usar una partición como una tabla, hay
que crear una vista seleccionando los datos de una partición simple, y luego utilizar la vista como una
tabla. La ventaja de este método es que se puede construir mecanismos de control de acceso basados
en el nivel de partición, dando o revocando los privilegios de estas vistas a otros usuarios o roles.

Tiene las siguientes restricciones:

No se puede utilizar con tablas remotas.


No soporta directamente PL/SQL.
No admite sinónimos.

Sintaxis

[schema.]{table | view} [@dblink | PARTITION (partition_name)]

Ejemplo

En la siguiente orden, SALES es una tabla particionada con partición JAN97. Puedes crear una
vista de la partición simple JAN97, y luego utilizarla como si fuera una tabla. Este ejemplo borra registros
de la partición:

CREATE VIEW sales_jan97 AS


SELECT * FROM sales PARTITION (jan97);
DELETE FROM sales_jan97 WHERE amount < 0;

2.10 Referencia a los objetos estructurados

Esta sección muestra como referenciar los objetos en el contexto de una orden SQL. En esta
sección se va a ver:

La sintaxis general para referenciar un objeto.


Como Oracle resuelve la referencia a un objeto.
Como referenciar objetos que no se encuentran en la estructura que uno posee.
Como referenciar objetos que se encuentran en una base de datos remota.

La sintaxis para referenciar un objeto es la siguiente:

[SCHEMA.] OBJECT [.PART] , [@DBLINK]

donde:

Sql_manual.doc 24
MANUAL DE SQL

object is the name of the object.


is the schema containing the object. The schema qualifier allows you to refer to an object in a schema
other than your own. Note that you must be granted privileges to refer to objects in other schemas. If you
schema
omit schema, Oracle assumes that you are referring to an object in your own schema.
Only schema objects can be qualified with schema. Schema objects are shown in Figure 2-2ch2.htm -
27617. Nonschema objects, shown in Figure 2-3ch2.htm - 27627, cannot be qualified with schema
because they are not schema objects. (An exception is public synonyms, which can optionally be qualified
with "PUBLIC". The quotation marks are required.)
is a part of the object. This identifier allows you to refer to a part of a schema object, such as a column or
part a partition of a table. Note that not all types of objects have parts.
applies only when you are using Oracle's distributed functionality. This is the name of the database
containing the object. The dblink qualifier allows you to refer to an object in a database other than your
dblink local database. If you omit dblink, Oracle assumes that you are referring to an object in your local
database. Note that not all SQL statements allow you to access objects on remote databases.

2.10.1 Como resuelve Oracle la referencia a objetos estructurados

Cuando te refieres a un objeto en una orden SQL, Oracle considera el contexto de la orden SQL
y localiza el objeto en el espacio de nombres apropiado. Después de localizar el objeto, Oracle depura la
operación que realiza la orden en el objeto. Si el nombre del objeto no puede ser localizado en el espacio
de nombres, Oracle retorna un error.

El siguiente ejemplo ilustra como Oracle resuelve las relaciones entre objetos en una orden SQL.
Considera la siguiente orden, que añade un registro de datos a una tabla identificada por el nombre
DEPT:

INSERT INTO dept


VALUES (50, ‘SUPPORT’, ‘PARIS’);

Basándose en el contexto de la orden, Oracle determina que DEPT puede ser:

Una tabla en su propio esquema.


Una vista en su propio esquema.
Un sinónimo privado de una tabla o una vista.
Un sinónimo publico.

Oracle siempre intenta resolver la referencia al objeto buscando en el espacio de nombres de su


propio esquema, antes de intentar buscarlo en otro esquema. En este ejemplo Oracle resuelve el nombre
DEPT de la siguiente manera:

1. Oracle intenta localizar el objeto en el espacio de nombres de su propio esquema, que


contiene tablas, vistas y sinónimos privados. Si el objeto es un sinónimo privado, Oracle
localiza el objeto a través del sinónimo. Este objeto puede estar en su propio esquema, en
otro esquema o en otra base de datos.
2. Si el objeto se encuentra en el espacio de nombres, Oracle ejecuta la orden sobre el objeto.
3. Si el objeto no se encuentra en el espacio de nombres, Oracle busca que el espacio de
nombres contenga un sinónimo publico. Si lo encuentra, Oracle ejecuta la orden sobre él. Si
no lo encuentra Oracle retorna un error.

Sql_manual.doc 25
MANUAL DE SQL

2.10.2 Referencias a objetos en otros esquemas

Para referirse a objetos que se encuentran en un esquema que no es propio, habría que
referenciarlo de la siguiente manera:

Schema.object

Por ejemplo, esta orden borra la tabla EMP del esquema SCOTT:

DROP TABLE scott.emp

2.10.3 Referencias a objetos en otras bases de datos

2.10.3.1 Creación de enlaces a bases de datos

Para crear un enlace a una base de datos hay que utilizar el comando CREATE DATABASE
LINK. Este comando te permite especificar la siguiente información acerca del enlace a la base de datos:

El nombre del enlace a la base de datos.


El string de conexión para acceder a la base de datos remota.
El usuario y el password para acceder a la base de datos remota.

Oracle almacena toda esta información en el diccionario de datos.

2.10.3.2 Nombres de enlaces a bases de datos

El nombre del enlace a la base de datos puede tener una longitud de 128 bytes y puede incluir
los caracteres punto (.) y arroba (@). A continuación se muestra la sintaxis de cómo definir un nombre de
un enlace a una base de datos:

Dblink::= DATABASE [.DOMAIN] [@CONNECTION_DESCRIPTOR]

Donde:

specifies the name of the remote database to which the database link connects. The name of the
database remote database is specified by its initialization parameter DB_NAME.
specifies the domain of the remote database to which the database link connects. If you omit the
domains from the name of a database link, Oracle expands the name by qualifying the database with
domain the domain of your local database as it currently exists in the data dictionary, and then stores the link
name in the data dictionary.
allows you to further qualify a database link. Using connect descriptors, you can create multiple
connect_des database links to the same database. For example, you can use connect descriptors to create multiple
criptor database links to different instances of the Oracle Parallel Server that access the same database.

Sql_manual.doc 26
MANUAL DE SQL

2.10.3.3 Usuario y password

Oracle utiliza el usuario y el password para conectarse a la base de datos remota. El usuario y el
password para un enlace a una base de datos son opcionales.

2.10.3.4 String de conexión

El string de conexión es la especificación usada por Net8 para acceder a una base de datos
remota. Para un enlace a una base de datos es opcional.

2.10.3.5 Referencias a enlaces de base de datos

Los enlaces a bases de datos solamente están permitidos si sé esta usando Oracle con el
funcionamiento distribuido. Se puede especificar el nombre del enlace a la base de datos de las
siguientes maneras:

is the complete database link name as stored in the data dictionary, including the database, domain, and
complete
optional connect_descriptor components.
partial is the database and optional connect_descriptor components, but not the domain component.

Oracle realiza las siguientes tareas antes de conectarse a una base de datos remota:

Si el nombre del enlace a la base de datos especificado en la orden es parcial, Oracle


expande el nombre para contener el dominio de la base de datos local tal y como se
encuentra en la base de datos global del diccionario de datos.
Oracle primeramente busca un enlace a base de datos privado en su propio esquema, si no
lo encuentra busca un enlace a base de datos publico:

Oracle siempre determina el usuario y el password del primer enlace a base de datos
que encuentra. Si el enlace tiene asociado un usuario con su password, Oracle utiliza
estos, si no es así, Oracle utiliza los que tiene por defecto
Si en la primera búsqueda Oracle encuentra un string de conexión, lo utiliza. De no ser
así busca el siguiente enlace a base de datos publico.

Oracle utiliza el string de conexión para acceder a la base de datos remota. Tiene que
cumplir que el dominio y el nombre de la base de datos remota coincidan para poder
conectarse.

Sql_manual.doc 27
MANUAL DE SQL

3 Operadores, funciones y condiciones

3.1 Operadores

Un operador manipula los datos individualmente y devuelve un resultado. Los operadores están
representados por caracteres especiales o por teclas.

3.1.1 Operadores binarios y unitarios

Hay dos clases de operadores:

Unary A unary operator operates on only one operand. A unary operator typically appears with its
operand in this format:

operator operand
Binary A binary operator operates on two operands. A binary operator appears with its operands in this
format:

operand1 operator operand2

Hay otros operadores que tienen un formato especial, que soportan más de dos operandos. Si
en un operador uno de los operandos es nulo, el resultado es siempre nulo.

3.1.2 Preferencia

La preferencia es el orden en el cual Oracle evalúa los diferentes operadores en una misma
expresión.

Tabla 3.1 Preferencia de los operadores

Operador Operación
+, - identity, negation
*, / Multiplication, division
+, -, || addition, subtraction, concatenation
=, !=, <, >, <=, >=, IS NULL, LIKE, BETWEEN, IN Comparison
NOT logical negation
AND Conjunction
OR Disjunction

Se pueden utilizar los paréntesis en las expresiones, Oracle primero evaluará lo que hay dentro
de los paréntesis, y a continuación lo que se encuentra fuera de ellos.

Sql_manual.doc 28
MANUAL DE SQL

3.1.3 Operadores aritméticos

Se puede utilizar un operador aritmético en una expresión para negar, añadir, restar, multiplicar y
dividir valores numéricos. El resultado de la operación es también un valor numérico.

Tabla 3.2 Operadores aritméticos

Operador Propósito Ejemplo


+- Denotes a positive or negative expression. These SELECT * FROM orders
are unary operators. WHERE qtysold = -1;
SELECT * FROM emp
WHERE -sal < 0;
*/ Multiplies, divides. These are binary operators. UPDATE emp
SET sal = sal * 1.1;
+- Adds, subtracts. These are binary operators. SELECT sal + comm FROM emp
WHERE SYSDATE - hiredate
> 365;

3.1.4 Operador de concatenación

El operador de concatenación manipula strings.

Tabla 3.3 Operador de concatenación

Operador Propósito Ejemplo


|| Concatenates character strings. SELECT 'Name is ' || ename
FROM emp;

El resultado de la concatenación de dos strings es otro string. El tipo de datos del string que
queda después de la concatenación es del mismo tipo que los strings que se concatenan.

Ejemplo

Este ejemplo crea una tabla con columnas de tipo CHAR y VARCHAR2, inserta valores en
ambas y a continuación hace una consulta de estos valores, concatenándolos.

CREATE TABLE tab1 (col1 VARCHAR2(6), col2 CHAR(6),


col3 VARCHAR2(6), col4 CHAR(6) );

Table created.

INSERT INTO tab1 (col1, col2, col3, col4)


VALUES ('abc', 'def ', 'ghi ', 'jkl');
1 row created.

SELECT col1||col2||col3||col4 "Concatenation"


FROM tab1;

Concatenation
------------------------

Sql_manual.doc 29
MANUAL DE SQL

abcdef ghi jkl

3.1.5 Operadores de comparación

Los operadores de comparación comparan dos expresiones. El resultado de la comparación


puede ser TRUE, FALSE o UNKNOWN.

Tabla 3.4 Operadores de comparación

Operador Propósito Ejemplo


= Equality test. SELECT *
FROM emp
WHERE sal = 1500;
!=, ^= Inequality test. Some forms of the inequality operator SELECT *
<>, ¬= may be unavailable on some platforms. FROM emp
WHERE sal != 1500;
> "Greater than" and "less than" tests. SELECT * FROM emp
WHERE sal > 1500;
<
SELECT * FROM emp
WHERE sal < 1500;
>= "Greater than or equal to" and "less than or equal to" SELECT * FROM emp
tests. WHERE sal >= 1500;
<=
SELECT * FROM emp
WHERE sal <= 1500;
IN "Equal to any member of" test. Equivalent to "= SELECT * FROM emp
ANY". WHERE job IN
('CLERK','ANALYST');

SELECT * FROM emp


WHERE sal IN
(SELECT sal FROM emp
WHERE deptno = 30);
NOT IN Equivalent to "!=ALL". Evaluates to FALSE if any SELECT * FROM emp
member of the set is NULL. WHERE sal NOT IN
(SELECT sal FROM emp
WHERE deptno = 30);

SELECT * FROM emp


WHERE job NOT IN
('CLERK', ANALYST');
ANY Compares a value to each value in a list or returned SELECT * FROM emp
SOME by a query. Must be preceded by =, !=, >, <, <=, >=. WHERE sal = ANY
Evaluates to FALSE if the query returns no rows. (SELECT sal FROM emp
WHERE deptno = 30);
ALL Compares a value to every value in a list or returned SELECT * FROM emp
by a query. Must be preceded by =, !=, >, <, <=, >=. WHERE sal >=
Evaluates to TRUE if the query returns no rows. ALL ( 1400, 3000);
[NOT] [Not] greater than or equal to x and less than or SELECT * FROM emp

Sql_manual.doc 30
MANUAL DE SQL

Operador Propósito Ejemplo


BETWEEN equal to y. WHERE sal
X AND y BETWEEN 2000 AND 3000;
EXISTS TRUE if a subquery returns at least one row. SELECT ename, deptno
FROM dept
WHERE EXISTS
(SELECT * FROM emp
WHERE dept.deptno
= emp.deptno);
X [NOT] TRUE if x does [not] match the pattern y. Within y, See "LIKE Operator".
LIKE y the character "%" matches any string of zero or more
characters except null. The character "_" matches SELECT * FROM tab1
[ESCAPE any single character. Any character, excepting WHERE col1 LIKE
'z'] percent (%) and underbar (_) may follow ESCAPE; a 'A_C/%E%' ESCAPE '/';
wildcard character is treated as a literal if preceded
by the character designated as the escape
character.
IS Tests for nulls. This is the only operator that you SELECT ename, deptno
[NOT] should use to test for nulls. See "Nulls". FROM emp
NULL WHERE comm IS NULL;

3.1.6 Operador NOT IN

Si cualquier campo de la lista siguiente es nulo, todos los registros serán evaluados a
UNKNOWN (y no retornara ningún registro). Por ejemplo, la siguiente instrucción retornará el string
‘TRUE’ para cada registro que cumpla la condición:

SELECT 'TRUE'
FROM emp
WHERE deptno NOT IN (5,15);

Sin embargo, la siguiente instrucción no retornará ningún registro:

SELECT 'TRUE'
FROM emp
WHERE deptno NOT IN (5,15,null);

El ejemplo de arriba no retorna ningún registro porque la cláusula WHERE evalúa:

deptno != 5 AND deptno != 15 AND deptno != null

y como todas las operaciones que comparen un valor nulo, el resultado es un nulo, la expresión entera
resulta un nulo.

3.1.7 Operador LIKE

Es usado en comparaciones con plantilla de strings de caracteres. La sintaxis para una condición
utilizando el operador LIKE es la siguiente:

Sql_manual.doc 31
MANUAL DE SQL

Char1 [NOT] LIKE char2 [ESCAPE ‘ esc_char’]

Donde:

char1 is a value to be compared with a pattern. This value can have datatype CHAR or
VARCHAR2.
NOT logically inverts the result of the condition, returning FALSE if the condition evaluates to
TRUE and TRUE if it evaluates to FALSE.
char2 is the pattern to which char1 is compared. The pattern is a value of datatype CHAR or
VARCHAR2 and can contain the special pattern matching characters % and _.
ESCAPE identifies a single character as the escape character. The escape character can be used to
cause Oracle to interpret % or _ literally, rather than as a special character, in the pattern.

Si se desea buscar strings que contengan un carácter de escape, se debe especificar también
este carácter. Por ejemplo, si el carácter de escape es ‘/’, para buscar la cadena ‘client/server’, se debe
especificar ‘client//server’.

Hay diferencias cuando es utiliza el operador = y el operador LIKE. Por ejemplo, la siguiente
consulta muestra los salarios de todos los empleados cuyo nombre comience por ‘SM’:

SELECT sal
FROM emp
WHERE ename LIKE 'SM%';

La siguiente consulta utiliza el operador =, y muestra los salarios de los empleados cuyo nombre
sea ‘SM%’:

SELECT sal
FROM emp
WHERE ename = 'SM%';

Los caracteres especiales que se pueden utilizar con el operador LIKE son los siguientes:

El underscore (_), representa un solo carácter.


El signo de tanto por ciento (%), representa ningún o muchos caracteres.

3.1.7.1 Opción ESCAPE

Se pueden incluir los caracteres ‘%’ y ‘_’ en una búsqueda utilizando la opción ESCAPE. La
opción ESCAPE identifica el carácter de escape.

Ejemplo

Para buscar los empleados que contengan ‘A_B’ en su nombre se hace lo siguiente:

SELECT ename
FROM emp
WHERE ename LIKE '%A\_B%' ESCAPE '\';

Sql_manual.doc 32
MANUAL DE SQL

La opción ESCAPE identifica el backslash (\) como un carácter de escape. En la consulta el


carácter de escape precede al underscore (_). Esto origina que Oracle interprete el underscore
literalmente.

3.1.8 Operadores lógicos

Un operador lógico combina el resultado de dos comparaciones para producir un resultado


simple.

Tabla 3.5 Operadores lógicos

Operador Propósito Ejemplo


NOT Returns TRUE if the following condition is FALSE. SELECT *
Returns FALSE if it is TRUE. If it is UNKNOWN, it FROM emp
remains UNKNOWN. WHERE NOT (job IS NULL);

SELECT *
FROM emp
WHERE NOT
(sal BETWEEN 1000 AND 2000);
AND Returns TRUE if both component conditions are SELECT *
TRUE. Returns FALSE if either is FALSE. FROM emp
Otherwise returns UNKNOWN. WHERE job = 'CLERK'
AND deptno = 10;
OR Returns TRUE if either component condition is SELECT *
TRUE. Returns FALSE if both are FALSE. Otherwise FROM emp
returns UNKNOWN. WHERE job = 'CLERK'
OR deptno = 10;

Ejemplo

SELECT *
FROM emp
WHERE hiredate < TO_DATE('01-JAN-1984', 'DD-MON-YYYY')
AND sal > 1000;

3.1.8.1 Operador NOT

Tabla 3.6 Operador NOT

NOT TRUE FALSE UNKNOWN


False True Unknown

Sql_manual.doc 33
MANUAL DE SQL

3.1.8.2 Operador AND

Tabla 3.7 Operador AND

AND TRUE FALSE UNKNOWN


TRUE True False Unknown
FALSE False False False
UNKNOWN Unknown False Unknown

3.1.8.3 Operador OR

Tabla 3.8 Operador OR

OR TRUE FALSE UNKNOWN


TRUE True True True
FALSE True False Unknown
UNKNOWN True Unknown Unknown

3.1.9 Operadores Set

Los operadores Set combinan el resultado de dos consultas en un único resultado.


Tabla 3.9 Operadores Set

Operador Retorna
UNION All rows selected by either query.
UNION ALL All rows selected by either query, including all duplicates.
INTERSECT All distinct rows selected by both queries.
MINUS All distinct rows selected by the first query but not the second.

Todos los operadores Set tienen igual preferencia. Si una instrucción SQL contiene múltiples
operadores Set, Oracle los evalúa de izquierda a derecha, siempre y cuando no haya paréntesis.

El tipo de dato del valor retornado depende de los tipos de datos de los componentes de la
consulta, si ambos son CHAR el resultado será CHAR, y si ambos son VARCHAR2 el resultado será
VARCHAR2.
Ejemplos
Considere estas dos consultas y sus resultados.
SELECT part
FROM orders_list1;
PART
----------
SPARKPLUG
FUEL PUMP
FUEL PUMP
TAILPIPE

SELECT part
FROM orders_list2;

PART

Sql_manual.doc 34
MANUAL DE SQL

----------
CRANKSHAFT
TAILPIPE
TAILPIPE

Los siguientes ejemplos combinan los resultados de estas dos consultas.


UNION
Las siguientes instrucciones combinan el resultado con el operador Set UNION, el cual elimina
los registros duplicados:

SELECT part, partnum, to_date(null) date_in


FROM orders_list1
UNION
SELECT part, to_null(null), date_in
FROM orders_list2;
PART PARTNUM DATE_IN
---------- ------- --------
SPARKPLUG 3323165
SPARKPLUG 10/24/98
FUEL PUMP 3323162
FUEL PUMP 12/24/99
TAILPIPE 1332999
TAILPIPE 01/01/01
CRANKSHAFT 9394991
CRANKSHAFT 09/12/02

SELECT part
FROM orders_list1
UNION
SELECT part
FROM orders_list2;

PART
----------
SPARKPLUG
FUEL PUMP
TAILPIPE
CRANKSHAFT

UNION ALL

Las siguientes instrucciones combinan los resultados con el operador Set UNION ALL, el cual no
elimina los registros duplicados:

SELECT part
FROM orders_list1
UNION ALL
SELECT part
FROM orders_list2;

PART
----------

Sql_manual.doc 35
MANUAL DE SQL

SPARKPLUG TAILPIPE
FUEL PUMP CRANKSHAFT

INTERSECT
Las siguientes instrucciones combinan el resultado con el operador Set INTERSECT, el cual
únicamente retorna aquellos registros que son retornados por las dos consultas:
SELECT part
FROM orders_list1
INTERSECT
SELECT part
FROM orders_list2;

PART
----------
TAILPIPE
MINUS

Las siguientes instrucciones combinan el resultado con el operador Set MINUS, el cual retorna
únicamente los registros que retorna la primera consulta y que no retorna la segunda.
SELECT part
FROM orders_list1
MINUS
SELECT part
FROM orders_list2;

3.1.10 Otros operadores

Tabla 3.10 Otros operadores SQL

Operador Propósito Ejemplo


(+) Indicates that the preceding column is the outer join SELECT ename, dname
column in a join. See "Outer Joins". FROM emp, dept
WHERE dept.deptno =
emp.deptno(+);
PRIOR Evaluates the following expression for the parent row SELECT empno, ename, mgr
of the current row in a hierarchical, or tree-structured FROM emp
query. In such a query, you must use this operator in CONNECT BY
the CONNECT BY clause to define the relationship PRIOR empno = mgr;
between parent and child rows. You can also use this
operator in other parts of a SELECT statement that
performs a hierarchical query. The PRIOR operator is
a unary operator and has the same precedence as the
unary + and - arithmetic operators. See "Hierarchical
Queries".

3.2 Funciones SQL

Una función SQL es similar a un operador, en que ambos operan con datos y devuelven un
resultado. Las funciones son diferentes de los operadores en que aparecen con argumentos.

Sql_manual.doc 36
MANUAL DE SQL

Si se llama a una función SQL, y se le pasa un tipo de argumento con un tipo de dato distinto del
que tiene definido la función, Oracle convierte implícitamente el argumento al tipo de dato que tiene
definido la función.

Si en la llamada a una función SQL se le pasa como argumento un nulo, la función siempre
devuelve nulo. Las únicas funciones que no siguen esta regla son CONCAT, DECODE, DUMP, NVL y
REPLACE.

Las funciones SQL pueden ser de los siguientes tipos generales:

Funciones escalares (simples).


Funciones agregadas (de grupo).

Estos dos tipos difieren en el número de registros sobre los que pueden actuar. Una función
escalar retorna un único registro, de todos los registros de la tabla o vista sobre la que se ha efectuado la
consulta; una función agregada retorna un único registro, de un grupo de registros sobre los que se ha
efectuado la consulta.

3.2.1 Funciones numéricas

Las funciones numéricas aceptan argumentos numéricos, y devuelven valores numéricos.

3.2.1.1 ABS
Propósito Retorna el valor absoluto de n.

EjemploSELECT ABS(-15) "Absolute" FROM DUAL;


Absolute
----------
15

3.2.1.2 ACOS

Propósito Retorna el arcocoseno de n. Las entradas están en el rango de 1 a -1, y las salidas están
en el rango de 0 y están expresadas en radianes.

Ejemplo SELECT ACOS(.3)"Arc_Cosine" FROM DUAL;

Arc_Cosine
----------
1.26610367

3.2.1.3 ASIN

Propósito Retorna el arcoseno de n. Las entradas están en el rango de 1 a -1, y las salidas están en
el rango de –2 a 2 y están expresadas en radianes.

Ejemplo SELECT ASIN(.3) "Arc_Sine" FROM DUAL;

Sql_manual.doc 37
MANUAL DE SQL

Arc_Sine
----------
.304692654

3.2.1.4 ATAN

Propósito Retorna el arcotangente de n. Las entradas están en un rango indefinido, y las salidas
están en el rango de –2 a 2 y están expresadas en radianes.

Ejemplo SELECT ATAN(.3) "Arc_Tangent" FROM DUAL;

Arc_Tangent
----------
.291456794

3.2.1.5 ATAN2

Propósito Retorna el arcotangente de n y m.

Ejemplo SELECT ATAN2(.3, .2) "Arc_Tangent2" FROM DUAL;

Arc_Tangent2
------------
.982793723

3.2.1.6 CEIL

Propósito Retorna el entero más pequeño mayor o igual que n.

Ejemplo SELECT CEIL(15.7) "Ceiling" FROM DUAL;

Ceiling
----------
16

3.2.1.7 COS

Propósito Retorna el coseno de n (el ángulo expresado en radianes).

Ejemplo SELECT COS(180 * 3.14159265359/180)


"Cosine of 180 degrees" FROM DUAL;

Cosine of 180 degrees


---------------------
-1

Sql_manual.doc 38
MANUAL DE SQL

3.2.1.8 COSH

Propósito Retorna el coseno hiperbólico de n.

Ejemplo SELECT COSH(0)


"Hyperbolic cosine of 0" FROM DUAL;

Hyperbolic cosine of 0
----------------------
1

3.2.1.9 EXP

Propósito Retorna e elevado a n; e = 2.71828183 ...

Ejemplo SELECT EXP(4) "e to the 4th power" FROM DUAL;

e to the 4th power


------------------
54.59815

3.2.1.10 FLOOR

Propósito Retorna el entero mayor que sea igual o menor que n.

Ejemplo SELECT FLOOR(15.7) "Floor" FROM DUAL;

Floor
----------
15

3.2.1.11 LN

Propósito Retorna el logaritmo natural de n, cuando n es mayor que 0.

Ejemplo SELECT LN(95) "Natural log of 95" FROM DUAL;

Natural log of 95
-----------------
4.55387689

3.2.1.12 LOG

Propósito Retorna el logaritmo en base m de n. La base m puede ser cualquier número positivo y
n puede ser cualquier número positivo o negativo.

Ejemplo SELECT LOG(10,100) "Log base 10 of 100" FROM DUAL;

Sql_manual.doc 39
MANUAL DE SQL

Log base 10 of 100


------------------
2

3.2.1.13 MOD
Sintaxis MOD(m,n)
Propósito Retorna el resto de m dividido por n.

Ejemplo SELECT MOD(11,4) "Modulus" FROM DUAL;


Modulus
----------
3
Esta función tiene algunas diferencias con la función matemática del modulo. Para implementar
la función matemática del módulo habría que hacer lo siguiente:

m - n * FLOOR(m/n)

Las siguientes instrucciones muestran las diferencias entre la función matemática del módulo y la
función MOD de SQL:

SELECT m, n, MOD(m, n),


m - n * FLOOR(m/n) "Classical Modulus"
FROM test_mod_table;

M N MOD(M,N) Classical Modulus


---------- ---------- ---------- -----------------
11 4 3 3
11 -4 3 -1
-11 4 -3 1
-11 -4 -3 -3

3.2.1.14 POWER
Propósito Retorna m elevado a n. La base m y el exponente n pueden ser cualquier número, pero
si m es negativo, n debe ser un entero.

Ejemplo SELECT POWER(3,2) "Raised" FROM DUAL;

Raised
----------
9

3.2.1.15 ROUND

Sintaxis ROUND(n[,m])

Propósito Retorna n redondeado m lugares a la derecha del punto decimal; si m es omitido se


desplaza 0 lugares.

Ejemplo 1 SELECT ROUND(15.193,1) "Round" FROM DUAL;

Round
----------

Sql_manual.doc 40
MANUAL DE SQL

15.2

Ejemplo 2 SELECT ROUND(15.193,-1) "Round" FROM DUAL;

Round
----------
20

3.2.1.16 SIGN

Sintaxis SIGN(n)
Propósito Si n<0, la función retorna –1; si n=0,la función retorna 0; si n>0, la función retorna 1.
Ejemplo SELECT SIGN(-15) "Sign" FROM DUAL;
Sign
----------
-1

3.2.1.17 SIN

Propósito Retorna el seno de n (el ángulo expresado en radianes).

Ejemplo SELECT SIN(30 * 3.14159265359/180)


"Sine of 30 degrees" FROM DUAL;

Sine of 30 degrees
------------------
.5

3.2.1.18 SINH

Propósito Retorna el seno hiperbólico de n.

Ejemplo SELECT SINH(1) "Hyperbolic sine of 1" FROM DUAL;

Hyperbolic sine of 1
--------------------
1.17520119

3.2.1.19 SQRT

Propósito Retorna la raíz cuadrada de n. El valor de n no puede ser negativo.

Ejemplo SELECT SQRT(26) "Square root" FROM DUAL;

Square root
-----------
5.09901951

Sql_manual.doc 41
MANUAL DE SQL

3.2.1.20 TAN

Propósito Retorna la tangente de n (el ángulo expresado en radianes).

Ejemplo SELECT TAN(135 * 3.14159265359/180)


"Tangent of 135 degrees" FROM DUAL;

Tangent of 135 degrees


----------------------
-1

3.2.1.21 TANH

Propósito Retorna la tangente hiperbólica de n.

Ejemplo SELECT TANH(.5) "Hyperbolic tangent of .5"


FROM DUAL;

Hyperbolic tangent of .5
------------------------
.462117157

3.2.1.22 TRUNC

Propósito Retorna n truncado m lugares decimales; si m se omite se truncan 0 lugares. M puede


ser negativo para truncar m dígitos a la izquierda del punto decimal.

Ejemplos SELECT TRUNC(15.79,1) "Truncate" FROM DUAL;

Truncate
----------
15.7

SELECT TRUNC(15.79,-1) "Truncate" FROM DUAL;

Truncate
----------
10

3.2.2 Funciones de caracteres

3.2.2.1 Funciones de caracteres que retornan valores de tipo carácter

CHR

Sintaxis CHR(n [USING NCHAR_CS])

Sql_manual.doc 42
MANUAL DE SQL

Propósito Retorna el carácter cuando se le pasa n, que es el binario equivalente.

Si la cláusula USING NCHAR_CS no está especificada, está función retorna el carácter


equivalente como un VARCHAR2, si la cláusula si que está especificada, el tipo que
devuelve es NVARCHAR2.

Ejemplo 1 SELECT CHR(67)||CHR(65)||CHR(84) "Dog"


FROM DUAL;
Dog
---
CAT

Ejemplo 2 SELECT CHR(16705 USING NCHAR_CS) FROM DUAL;

C
-
A

CONCAT

Sintaxis CONCAT(char1, char2)

Propósito Retorna el primer carácter concatenado con el segundo. Esta función es equivalente al
operador de concatenación.

Ejemplo SELECT CONCAT( CONCAT(ename, ' is a '), job) "Job"


FROM emp
WHERE empno = 7900;

Job
-----------------
JAMES is a CLERK

INITCAP

Propósito Retorna caracteres, con la primera letra de cada palabra en mayúscula, y las demás en
minúscula. Las palabras están delimitadas por caracteres en blanco.

Ejemplo SELECT INITCAP('the soap') "Capitals" FROM DUAL;

Capitals
---------
The Soap
LOWER

Propósito Retorna caracteres con todas las letras en minúscula.

Ejemplo SELECT LOWER('MR. SCOTT MCMILLAN') "Lowercase"

Sql_manual.doc 43
MANUAL DE SQL

FROM DUAL;

Lowercase
--------------------
mr. scott mcmillan
LTRIM

Sintaxis LTRIM(char [,set])

Propósito Cambia los caracteres que se encuentran a la izquierda de char, por el carácter que
viene especificado en set.

EjemploSELECT LTRIM('xyxXxyLAST WORD','xy') "LTRIM example"


FROM DUAL;

LTRIM exampl
------------
XxyLAST WORD

REPLACE

Sintaxis REPLACE(char,search_string[,replacement_string])

Propósito Retorna char con todas las ocurrencias que aparecen en search_string, reemplazadas
por replacement_string. Si replacement_string no se define todos los caracteres que
cumplan con la ocurrencia search_string se borrarán.

Ejemplo SELECT REPLACE('JACK and JUE','J','BL') "Changes"


FROM DUAL;

Changes
--------------
BLACK and BLUE

RPAD

Sintaxis RPAD(char1, n [,char2])

Propósito Retorna char1, pero se le añadido al final char2 hasta que llegue a ocupar el tamaño
especificado por n. Si char1 es mayor que n, char1 se cortaría por la posición que
marque n.

Ejemplo SELECT RPAD('MORRISON',12,'ab') "RPAD example"


FROM DUAL;

RPAD example
-----------------
MORRISONabab

RTRIM

Sql_manual.doc 44
MANUAL DE SQL

Sintaxis RTRIM(char [,set]

Propósito RTRIM trabaja de forma similar a LTRIM, la única diferencia es que RTRIM es por la
derecha y LTRIM es por la izquierda.

Ejemplo SELECT RTRIM('BROWNINGyxXxy','xy') "RTRIM e.g."


FROM DUAL;

RTRIM e.g
-------------
BROWNINGyxX

SOUNDEX

Sintaxis SOUNDEX(char)
Propósito Retorna un string de caracteres que contiene la representación fonética de char.

Ejemplo SELECT ename


FROM emp
WHERE SOUNDEX(ename)
= SOUNDEX('SMYTHE');
ENAME
----------
SMITH
SUBSTR

Sintaxis SUBSTR(char, m [,n])

Propósito Retorna una porción de char, comenzando en el carácter m con n caracteres de


longitud. Si m es positivo cuenta a partir del comienzo de char, si m es negativo, cuenta
a partir del final de char y hacia la izquierda

Ejemplo 1 SELECT SUBSTR('ABCDEFG',3.1,4) "Subs"


FROM DUAL;

Subs
----
CDEF

Ejemplo 2 SELECT SUBSTR('ABCDEFG',-5,4) "Subs"


FROM DUAL;

Subs
----
CDEF

SUBSTRB

Sintaxis SUBSTR(char, m [,n])

Sql_manual.doc 45
MANUAL DE SQL

Propósito Funciona de igual manera que SUBSTR pero m y n en lugar de expresarlos en


caracteres se expresan en bytes.

Ejemplo SELECT SUBSTRB('ABCDEFG',5,4.2)


"Substring with bytes"
FROM DUAL;

Substring with bytes


--------------------
CD
TRANSLATE

Sintaxis TRANSLATE(char, from, to)

Propósito Retorna char con todas las ocurrencias señaladas en from reemplazadas por el
correspondiente carácter en to. El argumento from puede tener más caracteres que el
argumento to

Ejemplo 1 Las siguientes instrucciones traducen un número de licencia. Todas las letras ‘ABC..Z’
se traducen a ‘X’ y todos los dígitos ‘012..9’ se traducen a ‘9’:

SELECT TRANSLATE('2KRW229',
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
'9999999999XXXXXXXXXXXXXXXXXXXXXXXXXX') "License"
FROM DUAL;

License
--------
9XXX999

Ejemplo 2 La siguiente instrucción devuelve una licencia con las letras borradas:

SELECT TRANSLATE('2KRW229',
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ',
'0123456789')
"Translate example"
FROM DUAL;

Translate example
-----------------
2229

UPPER

Sintaxis UPPER(char)

Propósito Retorna char con todas las letras en mayúsculas.

Ejemplo SELECT UPPER('Large') "Uppercase"

Sql_manual.doc 46
MANUAL DE SQL

FROM DUAL;

Upper
-----
LARGE

3.2.2.2 Funciones de caracteres que retornan valores de tipo numérico

ASCII

Sintaxis ASCII(char)

Propósito Retorna la representación decimal del juego de caracteres de la base de datos de la


primera letra de char.

Ejemplo SELECT ASCII('Q')


FROM DUAL;

ASCII('Q')
----------
81

LENGTH

Sintaxis LENGTH(char)

Propósito Retorna el tamaño de char en caracteres. Si char es del tipo CHAR, incluye los espacios
en blanco.

Ejemplo SELECT LENGTH('CANDIDE') "Length in characters"


FROM DUAL;

Length in characters
--------------------
7

LENGTHB

Sintaxis LENGTHB(char)

Propósito Retorna el tamaño de char en bytes. Si char es nulo la función retorna nulo.

Ejemplo SELECT LENGTHB ('CANDIDE') "Length in bytes"


FROM DUAL;

Length in bytes
---------------
14

Sql_manual.doc 47
MANUAL DE SQL

NLSSORT

Sintaxis NLSSORT(char [, 'nlsparams'])

Propósito Retorna el string de bytes usados para ordenar char. El valor de ‘nlsparams’ puede
tener la siguiente forma:

'NLS_SORT = sort'

Ejemplo SELECT ename FROM emp


WHERE NLSSORT (ename, 'NLS_SORT = German')
> NLSSORT ('S', 'NLS_SORT = German') ORDER BY ename;

ENAME
----------
SCOTT
SMITH
TURNER
WARD

3.2.3 Funciones de fecha (DATE)

3.2.3.1 ADD_MONTHS

Sintaxis ADD_MONTHS(d,n)

Propósito Retorna la fecha d mas n meses. El argumento n puede ser cualquier entero.

Ejemplo SELECT TO_CHAR(


ADD_MONTHS(hiredate,1),
'DD-MON-YYYY') "Next month"
FROM emp
WHERE ename = 'SMITH';

Next Month
-----------
17-JAN-1981

3.2.3.2 LAST_DAY

Sintaxis LAST_DAY(d)

Propósito Retorna la fecha del último día del mes que contenga d. Esta función se puede utilizar
para determinar cuantos días quedan para terminar el mes.

Ejemplo 1 SELECT SYSDATE,

Sql_manual.doc 48
MANUAL DE SQL

LAST_DAY(SYSDATE) "Last",
LAST_DAY(SYSDATE) - SYSDATE "Days Left"
FROM DUAL;

SYSDATE Last Days Left


--------- --------- ----------
23-OCT-97 31-OCT-97 8

Ejemplo 2 SELECT TO_CHAR(


ADD_MONTHS(
LAST_DAY(hiredate),5),
'DD-MON-YYYY') "Five months"
FROM emp
WHERE ename = 'MARTIN';

Five months
-----------
28-FEB-1982

3.2.3.3 MONTHS_BETWEEN

Sintaxis MONTHS_BETWEEN(d1, d2)

Propósito Retorna el número de meses entre la fecha d1 y la fecha d2. Si d1 es posterior a d2, el
resultado es positivo, si no es negativo. Si las dos fechas se encuentran en el mismo día
del mes el resultado será un entero, de no ser así será fraccionario.

Ejemplo SELECT MONTHS_BETWEEN


(TO_DATE('02-02-1995','MM-DD-YYYY'),
TO_DATE('01-01-1995','MM-DD-YYYY') ) "Months"
FROM DUAL;

Months
----------
1.03225806

3.2.3.4 NEW_TIME

Sintaxis NEW_TIME(d, z1, z2)

Propósito Retorna la fecha y la hora en la zona z2 cuando la fecha y la hora en la zona z1 es d.

3.2.3.5 NEXT_DAY

Sintaxis NEXT_DAY(d, char).

Propósito Retorna la fecha del primer día de la semana nombrado por char que es posterior a la
fecha d. El argumento puede ser el día de la semana, el nombre completo o una
abreviatura.

Sql_manual.doc 49
MANUAL DE SQL

Ejemplo Este ejemplo retorna la fecha del siguiente Martes después del 15 de Marzo de 1992.

SELECT NEXT_DAY('15-MAR-92','TUESDAY') "NEXT DAY"


FROM DUAL;

NEXT DAY
---------
17-MAR-92

3.2.3.6 ROUND

Sintaxis ROUND(d[,fmt])

Propósito Retorna d redondeado a la unidad especificada en fmt. Si se omite fmt se redondea al


día más próximo.

Ejemplo SELECT ROUND (TO_DATE ('27-OCT-92'),'YEAR')


"New Year" FROM DUAL;

New Year
---------
01-JAN-93

3.2.3.7 SYSDATE

Sintaxis SYSDATE

Propósito Retorna la fecha y la hora actual.

Ejemplo SELECT TO_CHAR


(SYSDATE, 'MM-DD-YYYY HH24:MI:SS')"NOW"
FROM DUAL;

NOW
-------------------
10-29-1993 20:27:11

3.2.3.8 TRUNC

Sintaxis TRUNC(d,[fmt])

Propósito Retorna d con la porción de la hora truncada a la unidad especificada por fmt.

Ejemplo SELECT TRUNC(TO_DATE('27-OCT-92','DD-MON-YY'), 'YEAR')


"New Year" FROM DUAL;

New Year

Sql_manual.doc 50
MANUAL DE SQL

---------
01-JAN-92

3.2.3.9 ROUND and TRUNC

Tabla 3.11 Formatos de fecha para las funciones ROUND y TRUNC

Modelo de formato Unidad


CC, SCC One greater than the first two digits of a four-digit year.
SYYYY, YYYY, YEAR, Year (rounds up on July 1)
SYEAR
YYY, YY, Y
IYYY, IY, IY, I ISO Year
Q Quarter (rounds up on the sixteenth day of the second month of the
quarter)
MONTH, MON, MM, RM Month (rounds up on the sixteenth day)
WW Same day of the week as the first day of the year.

IW Same day of the week as the first day of the ISO year.
W Same day of the week as the first day of the month.
DDD, DD, J Day
DAY, DY, D Starting day of the week
HH, HH12, HH24 Hour
MI Minute

3.2.4 Funciones de conversión

Las funciones de conversión convierten un valor de un tipo de datos a otro.

3.2.4.1 CHARTOROWID

Sintaxis CHARTOROWID(char)

Propósito Convierte un valor de tipo CHAR o VARCHAR2 en un tipo ROWID.

Ejemplo SELECT ename FROM emp


WHERE ROWID = CHARTOROWID('AAAAfZAABAAACp8AAO');

ENAME
----------
LEWIS

3.2.4.2 CONVERT

Sintaxis CONVERT(char, dest_char_set [,source_char_set] )

Sql_manual.doc 51
MANUAL DE SQL

Propósito Convierte un string de caracteres de un conjunto de caracteres a otro conjunto de


caracteres.

El argumento char es el valor que va a ser convertido. El argumento dest_char es el


nombre del conjunto de caracteres en el cual char va a ser convertido. El argumento
source_char_set es el nombre del conjunto de caracteres con el que char está
almacenado en la base de datos.

Ejemplo SELECT CONVERT('Groß', 'US7ASCII', 'WE8HP')


"Conversion"
FROM DUAL;

Conversion
----------
Gross

3.2.4.3 HEXTORAW

Sintaxis HEXTORAW(char)

Propósito Convierte char que contiene dígitos hexadecimales a un valor de tipo RAW.

Ejemplo INSERT INTO graphics (raw_column)


SELECT HEXTORAW('7D') FROM DUAL;

3.2.4.4 RAWTOHEX

Sintaxis RAWTOHEX(raw)

Propósito Convierte raw a un valor de tipo carácter que contiene su hexadecimal correspondiente.

Ejemplo SELECT RAWTOHEX(raw_column) "Graphics"


FROM graphics;

Graphics
--------
7D
ROWIDTOCHAR

Sintaxis ROWIDTOCHAR(rowid)

Propósito Convierte un valor ROWID en un valor de tipo VARCHAR2. El resultado de esta


conversión siempre tiene una longitud de 18 caracteres.

Ejemplo SELECT ROWID


FROM offices
WHERE

Sql_manual.doc 52
MANUAL DE SQL

ROWIDTOCHAR(ROWID) LIKE '%Br1AAB%';

ROWID
------------------
AAAAZ6AABAAABr1AAB

3.2.4.5 TO_CHAR, date conversion


Sintaxis TO_CHAR(d [, fmt [, 'nlsparams'] ])

Propósito Convierte d que es de tipo DATE a un valor de tipo VARCHAR2 en el formato


especificado por fmt.

El argumento ‘nlsparams’ especifica el lenguaje en el cual se retornan los nombres del


mes y del día. Este argumento puede tener la siguiente forma:

'NLS_DATE_LANGUAGE = language'

Ejemplo SELECT TO_CHAR(HIREDATE, 'Month DD, YYYY')


"New date format" FROM emp
WHERE ename = 'BLAKE';

New date format


------------------
May 01, 1981

3.2.4.6 TO_CHAR, number conversion

Sintaxis TO_CHAR(n [, fmt [, 'nlsparams'] ])

Propósito Convierte n que es del tipo NUMBER a un valor de tipo VARCHAR2, especificando
opcionalmente el formato del número (fmt). Si se omite fmt, n se convierte a un valor de
tipo VARCHAR2 y tiene el tamaño necesario para que sea ocupado por todos los
dígitos.

Ejemplo 1 SELECT TO_CHAR(-10000,'L99G999D99MI') "Amount"


FROM DUAL;

Amount
--------------
$10,000.00-

Ejemplo 2 SELECT TO_CHAR(-10000,'L99G999D99MI',


'NLS_NUMERIC_CHARACTERS = '',.''
NLS_CURRENCY = ''AusDollars'' ') "Amount"
FROM DUAL;

Amount
-------------------
AusDollars10.000,00-

Sql_manual.doc 53
MANUAL DE SQL

3.2.4.7 TO_DATE

Sintaxis TO_DATE(char [, fmt [, 'nlsparams'] ])

Propósito Convierte char, que es de tipo CHAR o VARCHAR2 a un valor de tipo DATE. El
argumento fmt es el formato de la fecha en el que hay que convertir char.

Ejemplo INSERT INTO bonus (bonus_date)


SELECT TO_DATE(
'January 15, 1989, 11:00 A.M.',
'Month dd, YYYY, HH:MI A.M.',
'NLS_DATE_LANGUAGE = American')
FROM DUAL;

3.2.4.8 TO_NUMBER

Sintaxis TO_NUMBER(char [,fmt [, 'nlsparams'] ])

Propósito Convierte char, que es de tipo CHAR o VARCHAR2, a un valor de tipo NUMBER.

Ejemplo 1 UPDATE emp SET sal = sal +


TO_NUMBER('100.00', '9G999D99')
WHERE ename = 'BLAKE';

Ejemplo 2 SELECT TO_NUMBER('-AusDollars100','L9G999D99',


' NLS_NUMERIC_CHARACTERS = '',.''
NLS_CURRENCY = ''AusDollars''
') "Amount"
FROM DUAL;

Amount
----------
-100

3.2.5 Otras funciones

3.2.5.1 DUMP

Sintaxis DUMP(expr[,return_format[,start_position[,length]] ] )

Propósito Retorna un valor VARCHAR2 que contiene el código del tipo de datos, el tamaño en
bytes, y la representación interna de expr.

El argumento return_format especifica el formato del valor de retorno y puede tener


cualquiera de los valores abajo indicados.

8 retorna el resultado en notación octal.


10 retorna el resultado en notación decimal.
16 retorna el resultado en notación hexadecimal.
17 retorna el resultado como un carácter simple.

Sql_manual.doc 54
MANUAL DE SQL

El argumento start_position se combina con length para determinar que porción se


retorna de la representación interna. Por defecto se retorna todo.

Ejemplo 1 SELECT DUMP('abc', 1016)


FROM DUAL;

DUMP('ABC',1016)
------------------------------------------
Typ=96 Len=3 CharacterSet=WE8DEC: 61,62,63

Ejemplo 2 SELECT DUMP(ename, 8, 3, 2) "OCTAL"


FROM emp
WHERE ename = 'SCOTT';

OCTAL
----------------------------
Type=1 Len=5: 117,124

Ejemplo 3 SELECT DUMP(ename, 10, 3, 2) "ASCII"


FROM emp
WHERE ename = 'SCOTT';

ASCII
----------------------------
Type=1 Len=5: 79,84

3.2.5.2 EMPTY_[B | C]LOB


Sintaxis EMPTY_[B|C]LOB()

Propósito Retorna un localizador de LOB vacío que puede ser utilizado para inicializar una
variable LOB.

Ejemplo INSERT INTO lob_tab1 VALUES (EMPTY_BLOB());


UPDATE lob_tab1
SET clob_col = EMPTY_BLOB();

3.2.5.3 BFILENAME

Sintaxis BFILENAME ('directory', 'filename')

Propósito Retorna un localizador BFILE que es asociado con un fichero binario LOB en el sistema
de ficheros del servidor. El argumento directory es un alias del nombre completo del
sistema de ficheros del servidor donde se encuentran localizados actualmente los
ficheros. El argumento filename es el nombre del fichero en el sistema de ficheros del
servidor.

Ejemplo INSERT INTO file_tbl


VALUES (BFILENAME ('lob_dir1', 'image1.gif'));

3.2.5.4 GREATEST

Sql_manual.doc 55
MANUAL DE SQL

Sintaxis GREATEST(expr [,expr] ...)

Propósito Retorna el mayor de los valores que se encuentran en la lista de expresiones (expr).
Todas las expresiones que van a continuación de la primera expresión son convertidas
automáticamente al tipo de datos de la primera expresión antes de la comparación.

Ejemplo SELECT GREATEST ('HARRY', 'HARRIOT', 'HAROLD')


"Great" FROM DUAL;

Great
-----
HARRY

3.2.5.5 LEAST

Sintaxis LEAST(expr [,expr] ...)

Propósito Retorna el menor de los valores que se encuentran en la lista de expresiones (expr).
Todas las expresiones que van a continuación de la primera expresión son convertidas
automáticamente al tipo de datos de la primera expresión antes de la comparación.

Ejemplo SELECT LEAST('HARRY','HARRIOT','HAROLD') "LEAST"


FROM DUAL;

LEAST
------
HAROLD

3.2.5.6 NVL

Sintaxis NVL(expr1, expr2)

Propósito Si expr1 es nulo devuelve expr2; si expr1 no es nulo, entonces devuelve expr1. Los
argumentos expr1 y expr2 pueden ser de cualquier tipo, si los tipos son distintos Oracle
convierte automáticamente expr2 al tipo de expr1 antes de compararlos. El valor de
retorno será del mismo tipo que el de expr1 .

Ejemplo SELECT ename, NVL(TO_CHAR(COMM), 'NOT


APPLICABLE')
"COMMISSION" FROM emp
WHERE deptno = 30;

ENAME COMMISSION
---------- -------------------------------------
ALLEN 300
WARD 500
MARTIN 1400
BLAKE NOT APPLICABLE
TURNER 0
JAMES NOT APPLICABLE

Sql_manual.doc 56
MANUAL DE SQL

3.2.5.7 UID

Sintaxis UID

Propósito Retorna un entero que identifica unívocamente al actual usuario.

3.2.5.8 USER
Sintaxis USER

Propósito Retorna el actual usuario de Oracle mediante un tipo de datos VARCHAR2.

Ejemplo SELECT USER, UID FROM DUAL;

USER UID
------------------------------ ----------
SCOTT 19

3.2.5.9 USERENV
Sintaxis USERENV(option)

Propósito Retorna información de tipo VARCHAR2 de la actual sesión. El argumento option puede
tener los siguientes valores:
'ISDBA'
'LANGUAGE’
'TERMINA’
'SESSIONID’
'ENTRYID’
'LANG’
'INSTANCE'

Ejemplo SELECT USERENV('LANGUAGE') "Language" FROM DUAL;

Language
-----------------------------------
AMERICAN_AMERICA.WE8DEC

3.2.5.10 VSIZE
Sintaxis VSIZE(expr)

Propósito Retorna el número de bytes de la representación interna de expr.

Ejemplo SELECT ename, VSIZE (ename) "BYTES"


FROM emp
WHERE deptno = 10;

ENAME BYTES
---------- ----------
CLARK 5

Sql_manual.doc 57
MANUAL DE SQL

KING 4
MILLER 6

3.2.6 Funciones agrupadas

Las funciones agrupadas retornan resultados basados en un grupo de registros, en lugar de en


un único registro.

Algunas funciones agrupadas aceptan las siguientes opciones:

DISTINCT Esta opción implica que solo se consideren los valores que son distintos.
ALL Esta opción implica que considere todos los valores, incluidos los duplicados.

Todas las funciones agrupadas con la excepción de COUNT(*) ignoran los nulos.

3.2.6.1 AVG

Sintaxis AVG([DISTINCT|ALL] n)

Propósito Retorna la media del valor de n.

Ejemplo SELECT AVG(sal) "Average"


FROM emp;

Average
----------
2077.21429

3.2.6.2 COUNT
Sintaxis COUNT({* | [DISTINCT|ALL] expr})

Propósito Retorna el número de registros en una consulta.

Si se especifica expr, esta función retorna los registros en los cuales expr es no nula.
También se pueden contar todas las columnas o solamente aquellas que sean distintas.

Ejemplo 1 SELECT COUNT(*) "Total"


FROM emp;

Total
----------
18

Ejemplo 2 SELECT COUNT(job) "Count"


FROM emp;
Count
----------
14

Ejemplo 3 SELECT COUNT(DISTINCT job) "Jobs"


FROM emp;

Sql_manual.doc 58
MANUAL DE SQL

Jobs
----------
5

3.2.6.3 MAX

Sintaxis MAX([DISTINCT|ALL] expr)

Propósito Retorna el valor máximo de expr.

Ejemplo SELECT MAX(sal) "Maximum" FROM emp;

Maximum
----------
5000

3.2.6.4 MIN

Sintaxis MIN([DISTINCT|ALL] expr)

Propósito Retorna el valor mínimo de expr.

EjemploSELECT MIN(hiredate) "Earliest" FROM emp;

Earliest
---------
17-DEC-80

3.2.6.5 STDDEV

Sintaxis STDDEV([DISTINCT|ALL] x)

Propósito Retorna la desviación estándar de x.

EjemploSELECT STDDEV(sal) "Deviation"


FROM emp;

Deviation
----------
1182.50322

3.2.6.6 SUM

Sintaxis SUM([DISTINCT|ALL] n)

Propósito Retorna la suma de los valores de n.

Sql_manual.doc 59
MANUAL DE SQL

EjemploSELECT SUM(sal) "Total"


FROM emp;

Total
----------
29081

3.2.6.7 VARIANCE

Sintaxis VARIANCE([DISTINCT|ALL]x)

Propósito Retorna la varianza de x.

EjemploSELECT VARIANCE(sal) "Variance"


FROM emp;

Variance
----------
1389313.87

Sql_manual.doc 60
MANUAL DE SQL

4 Comandos

4.1 Comandos DDL (Data Definition Languaje)

Los comandos DDL permiten realizar las siguientes tareas:

Crear, modificar y borrar objetos estructurados.


Asignar y revocar privilegios y roles.
Analizar información en una tabla, índice o cluster.
Añadir comentarios al diccionario de datos.

4.1.1 ALTER CLUSTER

Redefine las características de almacenamiento y paralelismo de un cluster. Para poder


modificar el cluster, este se tiene que encontrar en el esquema propio o tener el privilegio de ALTER ANY
CLUSTER. La sintaxis es la siguiente:

ALTER CLUSTER [SCHEMA .] CLUSTER [opciones]

Para saber más acerca de las opciones consultar un manual.

4.1.1.1 Alteración de los cluster

Se pueden realizar las siguientes tareas con el comando ALTER CLUSTER:

Cambiar el valor del parámetro MAXTRANS para un bloque de datos del cluster.
Cambiar los valores de los parámetros SIZE, PCTUSED, PCTFREE e INITRANS para los
futuros bloques de datos del cluster.
Cambiar las futuras características de almacenamiento con las características de
STORAGE: NEXT, PCTINCREASE y MAXEXTENTS.

No se pueden realizar las siguientes tareas con el comando ALTER CLUSTER:

Cambiar el nombre o el número de las columnas en una llave cluster.


Cambiar los valores de los parámetros STORAGE INITIAL y MINEXTENTS.
Cambiar el espacio de tablas en el que esta almacenado el cluster.

Ejemplo 1

ALTER CLUSTER scott.customer


SIZE 512
STORAGE (MAXEXTENTS 25);

Ejemplo 2

ALTER CLUSTER scott.customer


DEALLOCATE UNUSED KEEP 30 K;

Sql_manual.doc 61
MANUAL DE SQL

4.1.2 ALTER DATABASE

Para modificar una base de datos es necesario tener el privilegio del sistema ALTER
DATABASE. Se puede alterar una base de datos existente en estos aspectos:

Montar y clonar la base de datos.


Convertir en Oracle7 el diccionario de datos, para realizar la migración a Oracle8.
Abrir la base de datos.
Elegir el modo ARCHIVELOG o NOARCHIVELOG.
Guardar el fichero de control actual.
Guardar los comandos SQL en la base de datos.
Cambiar el nombre global de la base de datos.
Cambiar el tamaño de uno o más ficheros de datos.

La sintaxis es la siguiente:

ALTER DATABASE database [opciones]

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1

ALTER DATABASE stock


ADD LOGFILE GROUP 3
(‘diska:log3.log’ ,
‘diskb:log3.log’) SIZE 50K;

Ejemplo 2

ALTER DATABASE stock


ADD LOGFILE MEMBER ‘diskc:log3.log’
TO GROUP 3;

Ejemplo 3

ALTER DATABASE stocks


ADD LOGFILE THREAD 5 GROUP 4
(‘diska:log4.log’ ,
‘diskb:log4.log’ ,
‘diskc:log4.log’);

4.1.3 ALTER FUNCTION

Para que este comando funcione, la función se debe encontrar en el propio esquema o tener el
privilegio de sistema ALTER ANY PROCEDURE. Sirve para recopilar una función almacenada. Su
sintaxis es la siguiente:

ALTER FUNCTION [schema] function COMPILE;

Sql_manual.doc 62
MANUAL DE SQL

Se puede utilizar el comando ALTER FUNCTION para recopilar explícitamente una función que
es invalida. El comando ALTER FUNCTION es similar al comando ALTER PROCEDURE.

Ejemplo

ALTER FUNCTION merriweather.get_bal COMPILE;

4.1.4 ALTER INDEX

Se utiliza el comando ALTER INDEX para:

Cambiar la unidad de almacenamiento o el nombre de un índice.


Renombrar, borrar, reconstruir, modificar, etc. las particiones de un índice.
Modificar los atributos de login y de paralelismo de índices no particionados.

Para utilizar esta orden el índice se debe encontrar en el propio esquema o se debe tener el
privilegio ALTER ANY INDEX. La sintaxis es la siguiente:

ALTER INDEX [schema] index [opciones];

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1

ALTER INDEX scott.customer


INITRANS 5
STORAGE (NEXT 100K);

Ejemplo 2

ALTER INDEX sales_ix3


MODIFY DEFAULT ATTRIBUTES INITRANS 5 STORAGE (NEXT 100K);

Ejemplo 3

ALTER INDEX artist_ix


REBUILD PARTITION p063 NOLOGGING;

Ejemplo 4

ALTER INDEX partnum_ix


SPILT PARTITION partnum_ix_p6 AT (5001)
INTO ( PARTITION partnum_ix_p5 TABLESPACE ts017 LOGGING,
PARTITION partum_ix_p6 TABLESPACE ts004);

Sql_manual.doc 63
MANUAL DE SQL

4.1.5 ALTER PACKAGE

Se utiliza para recopilar un paquete almacenado. Para poder ejecutar con éxito este comando el
paquete se debe encontrar dentro de nuestro propio esquema o tener el privilegio ALTER ANY
PROCEDURE. La sintaxis es la siguiente:

ALTER PACKAGE [schema] package COMPILE [{PACKAGE | BODY}]

Se puede utilizar este comando para recopilar explícitamente el cuerpo del paquete o la
especificación y el cuerpo del paquete. Para elegir lo que se quiere recopilar basta poner al final del
comando la opción PACKAGE o BODY.

Ejemplo

ALTER PACKAGE blair.accounting


COMPILE PACKAGE;

4.1.6 ALTER PROCEDURE

Se utiliza para recopilar un procedimiento almacenado. Para poder ejecutar satisfactoriamente


este comando, el procedimiento se debe encontrar en nuestro esquema o disponer del privilegio ALTER
ANY PROCEDURE. La sintaxis es la siguiente:

ALTER PROCEDURE [schema] procedure COMPILE

Este comando es similar al comando ALTER FUNCTION.

Ejemplo

ALTER PROCEDURE henry.close_acct


COMPILE;

4.1.7 ALTER ROLE

Sirve para cambiar la autorización necesaria para habilitar un role. Para poder ejecutar este
comando se tiene que pertenecer al role ADMIN OPTION o tener el privilegio ALTER ANY ROLE. La
sintaxis es la siguiente:

ALTER ROLE role { NOT IDENTIFIED | IDENTIFIED { BY password | EXTERNALLY | GLOBALLY }};

Ejemplo 1

ALTER ROLE analyst IDENTIFIED GLOBALLY;

Ejemplo 2

ALTER ROLE teller IDENTIFIED BY letter;

4.1.8 ALTER ROLLBACK SEGMENT

Sql_manual.doc 64
MANUAL DE SQL

Se utiliza para modificar el segmento rollback. Para poder ejecutar este comando se debe tener
el privilegio ALTER ROLLBACK SEGMENT. La sintaxis es la siguiente:

ALTER ROLLBACK SEGMENT rollback_segment


{ONLINE | OFFLINE | storage_clause |
SHRINK [ TO integer [{K | M}]]} ;

Ejemplo 1

ALTER ROLLBACK SEGMENT rsone ONLINE;

Ejemplo 2

ALTER ROLLBACK SEGMENT rsone


STORAGE (NEXT 100 MAXEXTENTS 20);

4.1.9 ALTER SEQUENCE

El propósito de este comando es cambiar la secuencia, de alguna de las siguientes maneras:

Cambiando el incremento entre futuros valores de secuencias.


Eliminando el valor máximo o mínimo.
Cambiando el número de números de secuencia chequeados.

Para poder ejecutar este comando es necesario tener el privilegio ALTER ANY SEQUENCE. La
sintaxis es la siguiente:

ALTER SEQUENCE [schema.] sequence [ INCREMENT BY integer ,


{ MAXVALUE integer | NOMAXVALUE } ,
{ MIN VALUE integer | NOMINVALUE } ,
{ CICLE | NOCICLE} ,
{ CACHE integer | NOCACHE } ,
{ ORDER | NOORDER } ];

Ejemplo
ALTER SEQUENCE eseq MAXVALUE 1500;

4.1.10 ALTER TABLE

Se utiliza para modificar la definición de una tabla por alguna de las siguientes razones:

Añadir una columna.


Añadir una constraint de integridad.
Redefinir una columna.
Modificar las características de almacenamiento u otras características.
Habilitar, deshabilitar o borrar una constraint de integridad o un índice.
Permitir o no que se escriba en una tabla.
Renombrar una tabla o una partición de la tabla.
Modificar los atributos CACHE y NOCACHE.

Sql_manual.doc 65
MANUAL DE SQL

Para poder ejecutar este comando, se tiene que ejecutar sobre tablas de tu propio esquema o
tener el privilegio ALTER ANY TABLE. Algunas veces también es necesario disponer del privilegio
CREATE ANY INDEX. La sintaxis es la siguiente:

ALTER TABLE [ schema.] table [ [{ conjunto_1 | conjunto_2 }] ,


[ paralel_clause] , [{ conjunto_3 | conjunto_4 }] ] ;

A continuación se van a definir cada uno de los conjuntos y sus partes.

Conjunto_1 {{ ADD ({ add_column_options | . }) | MODIFY ({ modify_columns_options | . }) |


Physical_attributes_clause |
{ LOGGING | NOLOGGING } |
{ LOB_storage_clauses | . } |
{ modify_LOB_storages_clauses | . } |
{ nested_table_storage_clauses | . } |
drop_clause |
{ allocate_extent_clause | desallocate_unused_clause } |
{ CACHE | NOCACHE } }

Conjunto_2 { RENAME TO new_table_name |


Index_organized_table_clauses |
Partioning_clauses }

Conjunto_3 {enable_clauses |
ENABLE TABLE LOCK }

Conjunto_4 {disable_clauses |
DISABLE TABLE LOCK }

Para saber más de las cláusulas y de lo que significan mirar un manual. A continuación vamos a
ver una serie de ejemplos que ilustran la mayoría de las opciones que aporta ALTER TABLE.

4.1.10.1 Modificar la definición de las columnas

Ejemplo 1 Valores por defecto

ALTER TABLE accounts


MODIFY (bal DEFAULT NULL) ;

Ejemplo 2 Constraints de integridad ( I )

ALTER TABLE emp


ADD ( thrifplan NUMBER (7, 2),
Loancode CHAR (1) NOT NULL) ;

Ejemplo 3 Constraints de integridad ( II )

ALTER TABLE emp


MODIFY (thrifplan NUMBER (9, 2)) ;

Ejemplo 4 Constraints de integridad ( III )

Sql_manual.doc 66
MANUAL DE SQL

ALTER TABLE emp


PCTFREE 30
PCTUSED 60;

Ejemplo 5 Constraints de integridad ( IV )

ALTER TABLE emp


ALLOCATE EXTENT (SIZE 5K INSTANCE 4) ;

Ejemplo 6 Constraints de integridad ( V )

ALTER TABLE emp


MODIFY (bal DEFAULT 0) ;

4.1.10.2 Tablas organizadas por índices

Ejemplo 1

ALTER TABLE docindex INITRANS 4 ;

Ejemplo 2

ALTER TABLE docindex ADD OVERFLOW ;

Ejemplo 3

ALTER TABLE docindex OVERFLOW INITRANS 4 ;

4.1.10.3 Columnas LOB

Ejemplo 1

ALTER TABLE employee ADD ( resume CLOB)


LOB (resume) STORE AS resume_seg (TABLESPACE resume_ts) ;

Ejemplo 2

ALTER TABLE employee MODIFY LOB (resume) (CACHE) ;

4.1.10.4 REFs

Un valor REF es una referencia a un registro de una tabla. Si una tabla tiene una columna de tipo
REF, cada valor de la columna puede referenciar a un registro un una tabla diferente.

Ejemplo

CREATE TABLE emp

Sql_manual.doc 67
MANUAL DE SQL

(name VARCHAR2 (100),


salary NUMBER,
dept REF dept_t) ;

CREATE TABLE departaments OF dept_t ;

ALTER TABLE emp


ADD (SCOPE FOR (dept) IS departments) ;

ALTER TABLE emp


ADD (REF (dept) WITH ROWID) ;

4.1.11 ALTER TABLESPACE

Este comando se utiliza para modificar un espacio de tablas ya existente por alguna de las
siguientes razones:

Para añadir ficheros de datos.


Para renombrar ficheros de datos.
Para cambiar los parámetros de almacenado por defecto.
Para comenzar o finalizar una copia de seguridad.
Para habiliar o deshabilitar que se pueda escribir en el espacio de tablas.
Para cambiar el tamaño mínimo del espacio de tablas.

Para poder ejecutar este comando se tiene que tener el privilegio ALTER TABLESPACE. La
sintaxis es la siguiente:

ALTER TABLESPACE tablespace [opciones] ;

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1

ALTER TABLESPACE accounting


RENAME DATAFILE ‘diska:pay1.dbf’
TO ‘diskb:receive1.dbf’ ;

Ejemplo 2

ALTER TABLESPACE accounting NOLOGGING


ADD DATAFILE ‘disk3:pay3.dbf’
AUTOEXTENT ON
NEXT 10K
MAXSIZE 100K ;

4.1.12 ALTER TRIGGER

Este comando se utiliza para habilitar, deshabilitar o compilar un disparador de la base de datos.
Para poder ejecutarlo es necesario tener el privilegio ALTER ANY TRIGGER. La sintaxis es la siguiente:

Sql_manual.doc 68
MANUAL DE SQL

ALTER TRIGGER [schema.] trigger { ENABLE | DISABLE | COMPILE [DEBUG] }

Ejemplo

ALTER TRIGGER reorder DISABLE;


ALTER TRIGGER reorder ENABLE;

4.1.13 ALTER TYPE

Este comando se utiliza para recopilar la especificación y/o el cuerpo del tipo de un objeto, o
para cambiar la especificación del tipo de un objeto. Para poder ejecutar este comando se necesita tener
uno de los siguientes privilegios: CREATE TYPE, ALTER ANY TYPE o CREATE ANY TYPE. La sintaxis
es la siguiente:

ALTER TYPE [schema.] type_name [opciones] ;

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1

CREATE TYPE data_t AS OBJECT


(year NUMBER,
MEMBER FUNCTION prod (invent NUMBER) RETURN NUMBER) ;

CREATE TYPE BODY data_t IS


MEMBER FUNCTION prod (invent NUMBER) RETURN NUMBER IS
BEGIN
RETURN (year + invent);
END;
END;

ALTER TYPE data_t REPLACE AS OBJECT


(year NUMBER,
MEMBER FUNCTION prod (invent NUMBER) RETURN NUMBER,
MEMBER FUNCTION qtr (der_qtr DATE) RETURN CHAR );

CREATE OR REPLACE TYPE BODY data_t IS


MEMBER FUNCTION prod (invent NUMBER) RETURN NUMBER IS
BEGIN
RETURN (year + invent);
END;
MEMBER FUNCTION qtr (der_qtr DATE) RETURN CHAR IS
BEGIN
RETURN ‘FIRST’;
END;
END;

Ejemplo 2

CREATE TYPE link1 AS OBJECT


(a NUMBER);

Sql_manual.doc 69
MANUAL DE SQL

CREATE TYPE link2 SA OBJECT


(a NUMBER,
b link1,
MEMBER FUNCTION p (c1 NUMBER) RETURN NUMBER );

CREATE TYPE BODY link2 AS


MEMBER FUNCTION p (c1 NUMBER) RETURN NUMBER IS
BEGIN
T14 := link1(14);
Dbms_output.put_line(t14.a);
RETURN 5;
END;
END;

4.1.14 ALTER USER


Este comando se utiliza para cambiar al usuario de la base de datos alguna de las siguientes
características:

Mecanismo de autentificación de usuario.


Password.
El espacio de tablas por defecto para la creación de objetos.
El espacio de tablas para segmentos temporales creados por el usuario.
El acceso a espacio de tablas.
Los roles por defecto.

Para poder ejecutar este comando es necesario tener el privilegio ALTER USER. La sintaxis es
la siguiente:

ALTER USER user [opciones] ;

Para conocer más acerca de las opciones consultar un manual.


Ejemplo 1

ALTER USER scott


IDENTIFIED BY lion
DEFAULT TABLESPACE tstest;
Ejemplo 2
ALTER USER scott
DEFAULT ROLE ALL EXCEPT agent;

4.1.15 ALTER VIEW

Este comando se utiliza para recopilar una vista. Para poder ejecutar este comando es necesario
que la vista se encuentre en nuestro propio esquema o que tengamos el privilegio ALTER ANY TABLE.
La sintaxis es la siguiente:

ALTER VIEW [schema.] view COMPILE ;

Ejemplo

ALTER VIEW customer_view COMPILE;

Sql_manual.doc 70
MANUAL DE SQL

4.1.16 ANALYZE

Este comando se utiliza para realizar algunas de las siguientes funciones en índices o tablas:

Para obtener estadísticas acerca del objeto.


Para borrar las estadísticas del objeto.
Para validar la estructura del objeto.

Para poder ejecutar este comando es necesario que el objeto se encuentre en nuestro propio
esquema o tener el privilegio ANALYZE ANY. La sintaxis es la siguiente:

ANALYZE { INDEX | TABLE | CLUSTER } [schema.] [opciones];

Ejemplo 1

ANALYZE TABLE emp COMPUTE STATISTICS FOR COLUMNS addr.street;

Ejemplo 2

ANALYZE TABLE emp


COMPUTE STATISTICS FOR COLUMNS sal SIZE 10;

Ejemplo 3

ANALYZE TABLE emp


VALIDATE STRUCTURE CASCADE;

Ejemplo 4

ANALYZE TABLE order_list


LIST CHAINED ROWS INTO cr;

4.1.17 COMMENT

Se utiliza para añadir comentarios acerca de una tabla, una vista o una columna en el diccionario
de datos. Para poder ejecutar este comando la tabla o la vista se tiene que encontrar en nuestro propio
esquema, o debemos de tener el privilegio COMMENT ANY TABLE. La sintaxis es la siguiente:

COMMENT ON { TABLE [schema.] { table | view } |


COLUMN [schema.] { table.column | view.column } }
IS ‘text’ ;

Ejemplo

COMMENT ON shipping.notes
IS ‘Special packing or shipping instructions’ ;

4.1.18 Cláusula CONSTRAINT

Se utiliza para definir una constraint de integridad. Una constraint de integridad es una regla que
restringe los valores para una o más columnas en una tabla o en una tabla organizada por índices.

Sql_manual.doc 71
MANUAL DE SQL

Las cláusulas constraint pueden aparecer en cualquiera de los comandos ALTER TABLE o
CREATE TABLE. La sintaxis para una tabla es la siguiente:

CONSTRAINT constraint [opciones] ;

Para saber más acerca de las opciones consultar un manual.

4.1.18.1 Definición de constraint de integridad

Para definir una contraint de integridad hay que incluir la cláusula CONSTRAINT en una orden
CREATE TABLE o ALTER TABLE. La cláusula CONSTRAINT tiene dos formas sintácticas:

table_constraint. Puede imponer reglas a todas las columnas de una tabla. Aparece con las
órdenes CREATE TABLE o ALTER TABLE, y puedes definir cualquier tipo de constraint de
integridad excepto una constraint NOT NULL.
Column_constraint. Impone reglas únicamente a la columna en la cual se ha definido. Si
aparece con la orden CREATE TABLE puede definir cualquier tipo de constraint, pero si
aparece con la orden ALTER TABLE solo puede definir una constraint NOT NULL.

No se pueden crear constraints en columnas que sean de tipo LOB o REF.

4.1.18.2 Constraints NOT NULL

Este tipo de constraint especifica que una columna no puede contener nulos. Es necesario
especificar que dicha columna no puede admitir nulos ya que por defecto todas las columnas que se
crean pueden admitir nulos.

Ejemplo

ALTER TABLE emp


MODIFY (sal NUMBER CONSTRAINT nn_sal NOT NULL);

4.1.18.3 Constraints UNIQUE

Esta constraint designa a una columna o a un conjunto de columnas como claves únicas. Con
ello lo que se logra que dos registros de una tabla no tengan el mismo valor en una columna que tenga
una constraint UNIQUE. Una constraint UNIQUE si puede contener nulos.

Una columna con clave única no puede contener valores LOB y REF. Una misma columna no
puede ser combinación de clave única y clave primaria.

Definición de claves únicas.

Ejemplo

CREATE TABLE dept


(deptno NUMBER (2),
dname VARCHAR (9) CONSTRAINT unq_dname UNIQUE,
loc VARCHAR (10) );

Sql_manual.doc 72
MANUAL DE SQL

En el siguiente ejemplo la orden USING INDEX especifica las características de almacenamiento


del índice que Oracle crea para habilitar la constraint.

CREATE TABLE dept


(deptno NUMBER (2),
dname VARCHAR (9),
loc VARCHAR (10),
CONSTRAINT unq_dname UNIQUE (dname)
USING INDEX PCTFREE 20
TABLESPACE user_x
STORAGE (INITIAL 8K NEXT 6K) );

Definición de claves únicas compuestas

Puede contener como máximo 16 columnas.

Ejemplo

ALTER TABLE census


ADD CONSTRAINT unq_city_state
UNIQUE (city, state)
USING INDEX PCTFREE 5
TABLESPACE user_y
EXCEPTIONS INTO bad_keys_in_ship_cont;

4.1.18.4 Constraint PRIMARY KEY

Esta constraint designa a una columna o a un conjunto de columnas como clave/s primaria/s de
la tabla. Para satisfacer la constraint PRIMARY KEY, se deben cumplir las siguientes condiciones:

Un valor primary key no puede aparecer en más de un registro.


Ninguna columna que forme parte de una primary key puede contener un nulo.

Una tabla solo puede tener una primary key. Una primary key no puede ser de tipo LOB o REF.

Definición de una primary key

Ejemplo

CREATE TABLE dept


(deptno NUMBER(2),
dname VARCHAR2(9),
loc VARCHAR2(10),
CONSTRAINT pk_dept PRIMARY KEY (deptno) );

Sql_manual.doc 73
MANUAL DE SQL

Definición de una primary key compuesta

Oracle crea un índice en las columnas que son primary key. El número máximo de columnas que
pueden formar una primary key compuesta es de 16.

Ejemplo

ALTER TABLE ship_cont


ADD PRIMARY KEY (ship_no, container_no) DISABLE;

4.1.18.5 Constraints de integridad referencial

Este tipo de constraint designa a una columna o a un conjunto de columnas como foreign key, y
establecen una relación entre esta foreign key y una primary key o una unique key, llamadas referenced
key. La tabla en la que se define la foreign key se denomina tabla hija y la tabla en la que se encuentra la
referenced key es la tabla padre. Tiene las siguientes restricciones:

La foreign key y la primary/unique key no se pueden encontrar en dos bases de datos


distintas.
En una misma tabla puede haber una foreign key y una referenced key.

Una constraint de integridad referencial tiene que cumplir las siguientes condiciones:

El valor de la foreign key de un registro debe aparecer como valor de una referenced key.
El valor de una columna foreign key puede ser nulo.

La constraint de integridad referencial se debe definir en la tabla hija. En la definición de una


constraint de integridad referencial pueden aparecer las siguientes palabras:

FOREIGN KEY. Identifica la columna o columnas que compone/n la foreign key.


REFERENCES. Identifica la tabla padre y la columna o combinación de columnas a las que
se hace referencia.
ON DELETE CASCADE. Permite que se borren los valores referenced key en la tabla padre,
y que cuando estos se borren Oracle borre los valores a los que hacía referencia en la tabla
hija.

Antes de definir una constraint de integridad referencial en la tabla hija, debe de estar definida la
constraint primary key en la tabla padre.

Definición de constraints de integridad referencial

Ejemplo

CREATE TABLE emp


(empno NUMBER(4),
ename VARCHAR2(10),
job VARCHA2(9),
mgr NUMBER(4),
hiredate DATE,
sal NUMBER(7, 2),
comm NUMBER(7, 2),
deptno CONSTRAINT fk_deptno REFERENCES dept (deptno) );

Sql_manual.doc 74
MANUAL DE SQL

Otra manera de definirlo sería:

CREATE TABLE emp


(empno NUMBER(4),
……………..
deptno,
CONSTRAINT fk_deptno
FOREIGN KEY (deptno)
REFERENCES dept (deptno) );

Mantenimiento de la integridad referencial con ON DELETE CASCADE

Ejemplo

CREATE TABLE emp


(empno NUMBER(4),
………………………..
deptno NUMBER(2) CONSTRAINT fk_deptno
REFERENCES dept (deptno)
ON DELETE CASCADE );

Constraints de integridad referencial con claves compuestas

Ejemplo

ALTER TABLE phone_calls


ADD CONSTRAINT fk_areaco_phoneno
FOREIGN KEY (areaco, phoneno)
REFERENCES customers(areaco, phoneno)
EXCEPTIONS INTO wrong_numbers ;

4.1.18.6 Constraint CHECK

Una constraint CHECK define explícitamente una condición. La condición de una constraint
CHECK puede hacer referencia a cualquier columna de una tabla, pero no a columnas de otras tablas. La
constraint CHECK no puede contener las siguientes construcciones:

Consultas referentes a valores en otros registros.


Llamadas a las funciones SYSDATE, UID, USER, USERENV.
Las pseudocolumnas CURRVAL, NEXTVAL, LEVEL o ROWNUM.
Constantes de tipo DATE que no están especificadas completamente.

Ejemplo 1

CREATE TABLE dept (deptno NUMBER CONSTRAINT check_deptno


CHECK (deptno BETWEEN 10 AND 99)
DISABLE,
Dname VARCHAR2(9) CONSTRAINT check_dname
CHECK (dname = UPPER (dname))
DISABLE,
Loc VARCHAR2(10) CONSTRAINT check_loc

Sql_manual.doc 75
MANUAL DE SQL

CHECK (loc IN (‘DALLAS’ , ‘BOSTON’, ‘NEW YORK’, ‘CHICAGO’))


DISABLE);

4.1.18.7 Constraints DEFERRABLE

DEFERREABLE significa que la constraint no será chequeada hasta que la transacción se


actualice (commit). Por defecto todas las constraints están NOT DEFERREABLE.

Ejemplo

CREATE TABLE orders


(ord_num NUMBER CONSTRAINT unq_num UNIQUE (ord_num)
INITIALLY DEFERRED DEFERREABLE);

4.1.18.8 Constraints habilitadas y deshabilitadas

Las constraints pueden tener uno de estos tres estados: DISABLE, ENABLE NOVALIDATE o
ENABLE VALIDATE.

Cuando se toma una constraint para habilitarla o deshabilitarla es necesario tener acceso
exclusivo sobre la tabla, ya que mientras los datos antiguos son chequeados, no se pueden introducir
datos nuevos en la tabla. Solo se puede chequear un constraint cada vez.

4.1.19 CREATE CLUSTER

Este comando se utiliza para crear un cluster. Un cluster es un objeto estructurado que contiene
una o más tablas, y todas ellas tienen una o más columnas en común. Para poder crear un cluster en
nuestro propio esquema es necesario tener el privilegio CREATE CLUSTER, y para poder crearlo en
cualquier otro esquema es necesario el privilegio CREATE ANY CLUSTER. La sintaxis es la siguiente:

CREATE CLUSTER [schema.] cluster, columns datatype [opciones];

Para conocer más acerca de las opciones consultar un manual.

4.1.19.1 Acerca de los cluster

Un cluster es un objeto que contiene una o más tablas, y que todas ellas tienen una o más
columnas en común. Los registros de una o más tablas que contienen el mismo valor en común son
físicamente almacenados conjuntamente.

La clusterización provee de un mayor control del almacenamiento físico, reduce el tiempo de


acceso a las tablas y reduce el espacio necesario para almacenar una tabla.

Ejemplo

Las siguientes instrucciones añaden las tablas emp y dept a un cluster.

CREATE TABLE emp


(empno NUMBER PRIMARY KEY,
ename VARCHAR2(10) NOT NULL

Sql_manual.doc 76
MANUAL DE SQL

CHECK (ename = UPPER (ename)),


Job VARCAHR2(9),
Mgr NUMBER REFERENCES scott.emp (empno),
Hiredate DATE CHECK (hiredate >= SYSDATE),
Sal NUMBER(10, 2) CHECK (sal >500),
Comm NUMBER(9, 0) DEFAULT NULL,
Deptno NUMBER(2) NOT NULL)
CLUSTER personal (deptno);

CREATE TABLE dept


(deptno NUMBER(2),
dname VARCHAR2(9),
loc VARCAHR2(9))
CLUSTER personal (deptno);

La siguiente instrucción crea el índice del cluster en la clave cluster de personal:

CREATE INDEX idx_personal ON CLUSTER personal;

Después de crear este índice se pueden introducir valores en las tablas dept y emp.

4.1.20 CREATE CONTROLFILE

Se utiliza para crear un fichero de control en alguno de los siguientes casos:

Todas las copias de los ficheros de control se han perdido.


Se quiere cambiar el nombre de la base de datos.

Para poder ejecutar este comando se tiene que tener habilitado el role OSDBA. La sintaxis es la
siguiente:

CREATE CONTROLFILE, [REUSE], [SET] DATABASE database [opciones];

Para conocer más acerca de las opciones consultar un manual.

Ejemplo

CREATE CONTROLFILE REUSE


DATABASE oreders_2
LOGFILE GROUP 1 (‘diskb:log1.log’, ‘diskc:log1.log’) SIZE 50K,
GROUP 2 (‘diskb:log2.log’, ‘diskc:log2.log’) SIZE 50K
NORESETLOGS
DATAFILE ‘diska:dbone.dat’ SIZE 2M
MAXLOGFILES 5
MAXLOGHISTORY 100
MAXDATAFILES 10
MAXINSTANCES 2
ARCHIVELOG;

Sql_manual.doc 77
MANUAL DE SQL

4.1.21 CREATE DATABASE

Se utiliza para crear una base de datos con las siguientes opciones:

Para establecer el máximo número de instancias, ficheros de datos, etc.


Para especificar el nombre y el tamaño de los ficheros de datos.
Para elegir el modo de uso.
Para especificar el juego de caracteres nacional y de la base de datos.

Para ejecutar este comando se tiene que tener habilitado el role OSDBA. La sintaxis es la
siguiente:

CREATE DATABASE database [opciones];

Para saber más acerca de las opciones consultar un manual.

Ejemplo

CREATE DATABASE newtest


CONTROLFILE REUSE
LOGFILE
GROUP 1 (‘diskb:log1.log’, ‘diskc:log1.log’) SIZE 50K,
GROUP 2 (‘diskb:log2.log’, ‘diskc:log2.log’) SIZE 50K
MAXLOGFILES 5
MAXLOGHISTORY 100
DATAFILE ‘diska:dbone.dat’ SIZE 2M
MAXDATAFILES 10
MAXINSTANCES 2
ARCHIVELOG
CHARACTER SET US7ASCII
NATIONAL CHARACTER SET JA16SJISFIXED
DATAFILE
‘disk1:df1.dbf’ AUTOEXTENT ON
‘disk2:df2.dbf’ AUTOEXTENT ON NEXT 10M MAXSIZE UNLIMITED;

4.1.22 CREATE FUNCTION

Se utiliza para crear una función almacenada o para registrar una función externa. Una función
almacenada es un conjunto de instrucciones PL/SQL que se puede llamar por su nombre.

Antes de que una función almacenada pueda ser creada, el usuario sys debe ejecutar el script
DBMSSTDX.SQL. Para poder crear una función almacenada en tu propio esquema es necesario el
privilegio CREATE PROCEDURE, y para poder crearla en otro esquema es necesario el privilegio
CREATE ANY PROCEDURE.

Para poder llamar a una función externa es necesario tener el privilegio EXECUTE sobre la
librería en la que reside la función.

Para incluir una instrucción CREATE FUNCTION en el precopilador de Oracle, se debe terminar
la instrucción con la palabra END-EXEC.

Sql_manual.doc 78
MANUAL DE SQL

La sintaxis es la siguiente:

CREATE [OR REPLACE] FUNCTION [schema.] function [opciones];

Para conocer más acerca de las opciones consultar un manual.

Ejemplo

CREATE FUNCTION get_bal (acc IN NUMBER) RETURN NUMBER IS


Acc_bal NUMBER(11, 2);
BEGIN
SELECT balance
INTO acc_bal
FROM accounts
WHERE accounts_id = acc_no;
RETURN (acc_bal);
END;

4.1.23 CREATE INDEX

Se utiliza para crear un índice en una o más columnas de una tabla, en tablas particionadas o en
un cluster. Un índice es un objeto que contiene una entrada por cada valor que aparece en la columna
indexada.

Para poder crear un índice en nuestro propio esquema, una de las siguientes condiciones debe
ser cierta:

Se debe tener el privilegio INDEX .


Se debe tener el privilegio CREATE ANY INDEX.

Para poder crear un índice en otro esquema es necesario tener el privilegio CREATE ANY
INDEX. La sintaxis es la siguiente:

CREATE [{ UNIQUE | BITMAP }] INDEX [schema.] index [opciones];

Para conocer más acerca de las opciones consultar un manual.

4.1.23.1 Creación de índices

Un índice es una lista ordenada de todos los valores que residen en un grupo de una o más
columnas. Es mucho más rápido crear un índice sobre una columna de una tabla antes de introducir
datos en la tabla, que introducir los datos en la tabla y crear posteriormente el índice. Un índice ordena
automáticamente los registros que se vayan introduciendo en la tabla.

Una columna con índice considera los valores nulos idénticos. Si se especifica que el índice sea
UNIQUE ya no pasaría este problema.

Sql_manual.doc 79
MANUAL DE SQL

4.1.23.2 Índices de columnas

Un índice puede contener un máximo de 32 columnas. La entrada del índice es la concatenación


de todas las columnas. Las columnas se pueden especificar en cualquier orden, pero influye.

Ejemplo

CREATE INDEX emp_indx1 ON emp(ename, job);


CREATE INDEX emp_indx2 ON emp(job, ename);

4.1.23.3 La opción NOSORT

Reduce sustancialmente el tiempo para crear un índice, ya que cuando se crea un índice sobre
una tabla que ya contiene registros, lo primero que hace es ordenar los registros y luego crea el índice.
Esta opción solo se puede utilizar cuando creamos índices sobre tablas. Esta opción también reduce el
espacio necesario para construir un índice.

Para poder utilizar esta opción es necesario que los registros estén ordenados de forma
ascendente, si no es así Oracle retorna un error.

4.1.23.4 NOLOGGING

Esta opción reduce substancialmente el tiempo requerido para crear un índice de gran tamaño.

Ejemplo

CREATE INDEX i_loc ON big_table (akey)


NOSORT
NOLOGGING
PARALLEL (DEGREE 5);

4.1.24 CREATE PACKAGE

Se utiliza para crear la especificación de un paquete almacenado. Un paquete es una colección


de funciones, procedimientos y otros objetos almacenados en la base de datos. La especificación es la
que declara estos objetos. La sintaxis es la siguiente:

CREATE [OR REPLACE] PACKAGE [schema.] package {IS | AS} pl/sql_package_spec ;

El uso de los paquetes es una alternativa a la creación de funciones y procedimientos. Los


paquetes tienen una serie de ventajas sobre los procedimientos y las funciones, son las siguientes:

Permite organizar las aplicaciones de una manera más eficiente.


Permite otorgar privilegios de una manera más eficiente.
Permite modificar los objetos del paquete sin tener que recopilar los objetos dependientes.
Oracle permite leer múltiples paquetes de memoria a la vez.
Puede contener variables globales y cursores que utilizan todos los procedimientos y
funciones del paquete.

Sql_manual.doc 80
MANUAL DE SQL

Al crear un paquete se crean por separado la especificación y el cuerpo del paquete.

Ejemplo

CREATE PACKAGE emp_mgmt AS


FUNCTION hire(ename VARCHAR2, job VARCHAR2, mgr NUMBER,
Sal NUMBER, comm NUMBER, deptno NUMBER)
RETURN NUMBER;
FUNCTION create_dept (dname VARCHAR2, loc VARCHAR2)
RETURN NUMBER;
PROCEDURE remove_emp (empno NUMBER);
PROCEDURE remove_dept (deptno NUMBER);
No_comm EXCEPTION;
No_sal EXCEPTION;
END emp_mgmt;

4.1.25 CREATE PACKAGE BODY

Se utiliza para crear el cuerpo de un paquete almacenado. El cuerpo define los objetos que se
han declarado en la especificación del paquete. La sintaxis es la siguiente:

CREATE [OR REPLACE] PACKAGE BODY [schema.] package { IS | AS } pl_sql_package_body;

Ejemplo

CREATE PACKAGE BODY emp_mgmt AS


Tot_emps NUMBER;
Tot_depts NUMBER;

FUNCTION hire (ename VARCHAR2, job VARCHAR2, mgr NUMBER, sal NUMBER,
Comm NUMBER, deptno NUMBER)
RETURN NUMBER IS
New_empno NUMBER(4);
BEGIN
SELECT empseq.NEXTVAL
INTO new_empno FROM DUAL;
INSERT INTO emp
VALUES (new_empno, ename, job, mgr, sal, comm, deptno);
Tot_emps := tot_emps + 1;
RETURN (new_empno);
END;

FUNCTION create_dept (dname VARCHAR2, loc VARCHAR2)


RETURN NUMBER IS
New_deptno NUMBER(4);
BEGIN
SELECT deptseq.NEXTVAL

Sql_manual.doc 81
MANUAL DE SQL

INTO new_deptno FROM DUAL;


INSERT INTO dept
VALUES (new_deptno, dname, loc);
Tot_depts := tot_depts + 1;
RETURN (new_deptno);
END;

PROCEDURE remove_emp (empno NUMBER) IS


BEGIN
DELETE FROM emp
WHERE emp.empno = remove_emp.empno;
Tot_emps := tot_emps – 1;
END;

PROCEDURE remove_dept (deptno NUMBER) IS


BEGIN
DELETE FROM dept
WHERE dept.deptno = remove_dept.deptno;
Tot_depts := tot_depts– 1;
END;

END emp_mgmt;

4.1.26 CREATE PROCEDURE

Se utiliza para crear un procedimiento almacenado o para registrar un procedimiento externo. Un


procedimiento es un grupo de instrucciones PL/SQL que se pueden llamar por su nombre.

Para poder crear un procedimiento antes el usuario sys, debe ejecutar el script
DBMSSTDX.SQL. Para crear un procedimiento en tu propio esquema hace falta el privilegio CREATE
PROCEDURE, y para crearlo en otro esquema hace falta el privilegio CREATE ANY PROCEDURE. Para
poder modificar algún procedimiento hace falta el privilegio ALTER ANY PROCEDURE.

Para poder realizar una llamada a un procedimiento externo hace falta tener el privilegio
EXECUTE sobre la librería en la cual reside el procedimiento. La sintaxis es la siguiente:

CREATE [OR REPLACE] PROCEDURE [schema.] procedure [opciones];

Para conocer más acerca de las opciones consultar un manual.

Ejemplo

CREATE PROCEDURE sam.credit (acc_no IN NUMBER, amount IN NUMBER) AS


BEGIN
UPDATE accounts
SET balance = balance + amount
WHERE account_id = acc_no;
END;

Sql_manual.doc 82
MANUAL DE SQL

4.1.27 CREATE ROLE

Se utiliza para crear un role. Un role es un juego de privilegios que puede ser asignado a un
usuario o a otro role. Para poder crear un role es necesario tener el privilegio CREATE ROLE. La sintaxis
es la siguiente:

CREATE ROLE role [{ NOT IDENTIFIED |


IDENTIFIED { BY password | EXTERNALLY | GLOBALLY }];

Hay algunos roles que ya están predefinidos, son los siguientes:

CONNECT.
RESOURCE.
DBA.
EXP_FULL_DATABASE.
IMP_FULL_DATABASE.
DELETE_CATALOG_ROLE.
EXECUTE_CATALOG_ROLE.
SELECT_CATALOG_ROLE.

Ejemplo

CREATE ROLE teller


IDENTIFIED BY cashflow;

4.1.28 CREATE ROLLBACK SEGMENT

Se utiliza para crear un segmento rollback. Un segmento rollback es un objeto que Oracle utiliza
para almacenar los datos necesarios para volver hacia atrás en el caso de que ocurra un error. Para crear
un segmento rollback es necesario tener el privilegio CREATE ROLLBACK SEGMENT. La sintaxis es la
siguiente:

CREATE [PUBLIC] ROLLBACK SEGMENT rollback_segment


[{ storage_clauses | TABLESPACE tablespace}];

Un espacio de tablas puede contener por lo general múltiples segmentos rollback.

Ejemplo

CREATE ROLLBACK SEGMENT rbs_2


TABLESPACE system;

4.1.29 CREATE SCHEMA

Se utiliza para crear múltiples tablas y vistas. Para poder crear un esquema es necesario tener
los privilegios CREATE TABLE y CREATE VIEW. La sintaxis es la siguiente:

CREATE SCHEMA AUTHORIZATION schema [{CREATE TABLE command |


CREATE VIEW command |
GRANT command }];

Sql_manual.doc 83
MANUAL DE SQL

La ventaja que tiene un esquema es que ejecuta toda la transacción de una sola vez.

Ejemplo

CREATE SCHEMA AUTHORIZATION blair


CREATE TABLE sox
(color VARCAHR2(10) PRIMARY KEY,
quantity NUMBER)
CREATE VIEW red_sox AS
SELECT color, quantity FROM sox WHERE color = ‘RED’
GRANT select ON red_sox TO waites;

4.1.30 CREATE SEQUENCE

Se utiliza para crear una secuencia. Una secuencia es un objeto con el cual los usuarios pueden
generar enteros únicos. Para poder crear una secuencia en nuestro propio esquema es necesario tener el
privilegio CREATE SEQUENCE, y para poder crearlo en cualquier esquema es necesario el privilegio
CREATE ANY SEQUENCE. La sintaxis es la siguiente:

CREATE SEQUENCE [schema.] sequence [opciones];

Para saber más sobre las opciones consultar un manual.

Cuando una secuencia numérica es creada, la secuencia se incrementa, independientemente de


si la transacción se actualiza o se produce un rollback. Las secuencias numéricas son generadas
independientemente de las tablas, por lo que la misma secuencia puede ser usada para múltiples tablas.

Cuando se crea una secuencia se puede especificar el valor mínimo y máximo que puede tomar,
el valor en el que debe comenzar, etc.

Ejemplo

CREATE SEQUENCE eseq


INCREMENT BY 10

4.1.31 CREATE SYNONYM

Se utiliza para crear un sinónimo. Un sinónimo es un nombre alternativo para tablas, vistas,
secuencias, procedimientos almacenados, funciones almacenadas, paquetes u otro sinónimo. Para poder
crear un sinónimo es necesario el privilegio CREATE SYNONYM o CREATE ANY SYNONYM según lo
creemos en nuestro propio esquema o no. La sintaxis es la siguiente:

CREATE [PUBLIC] SYNONYM [schema.] synonym [FOR] [schema.] object ;

Los sinónimos se crean por comodidad y conveniencia. Crear un sinónimo te permite:

Referenciar un objeto sin nombrar su propietario.


Referenciar un objeto sin tener que referenciar la base de datos en el que se encuentra.
Proveer de otro nombre a un objeto.

Sql_manual.doc 84
MANUAL DE SQL

Un sinónimo provee independencia de datos y transparencia de localización. En cada uno de los


esquemas solo puede haber un sinónimo privado con el mismo nombre.

Ejemplo

CREATE PUBLIC SYNONYM emp


FOR scott.emp@sales;

4.1.32 CREATE TABLE

Se utiliza para crear una tabla, especificando la siguiente información:

Definición de las columnas.


Definición de la organización de la tabla.
Constraints de integridad.
El espacio de tabla de las tablas.
Las características de almacenamiento.
El grado de paralelismo usado para crear una tabla.
Las definiciones de las particiones.

Para poder crear una tabla es necesario el privilegio CREATE TABLE o CREATE ANY TABLE,
según nos encontremos en nuestro esquema o no. La sintaxis es la siguiente:

CREATE TABLE [schema.] table [opciones];

Para conocer más acerca de las opciones consultar un manual.

Ejemplo

CREATE TABLE scott.emp


(empno NUMBER CONSTRAINT pk_emp PRIMARY KEY,
ename VARCHAR2(10) CONSTRAINT nn_ename NOT NULL,
CONSTRAINT upper_ename CHECK
(ename = UPPER (ename)),
job VARCHAR2(9),
mgr NUMBER CONSTRAINT fk_mgr REFERENCES
scott.emp(empno),
hiredate DATE DEFAULT SYSDATE,
sal NUMBER(10, 2) CONSTRAINT ck_sal CHECK (sal>500),
comm NUMBER(9, 0) DEFAULT NULL,
deptno NUMBER(2) CONSTRAINT nn_deptno NOT NULL
CONSTRAINT fk_deptno REFERENCES
Scott.dept (deptno))
PECTFREE 5 PCTUSED 75;

4.1.32.1 Tablas organizadas por índices

Sql_manual.doc 85
MANUAL DE SQL

Ejemplo

CREATE TABLE docindex


(token CHAR(20),
doc_oid INTEGER,
token_frecuency SMALLINT,
token_ocurrenced_data VARCAHR2(512),
CONSTRAINT pk_docindex PRIMARY KEY (token, doc_oid))
ORGANIZATION INDEX TABLESPACE text_collection
PCTTHRESHOLD 20 INCLUDING token_frecuency
OVERFLOW TABLESPACE text_collection_overflow;

4.1.32.2 Tablas particionadas

Una tabla particionada consiste en un número de piezas que tienen los mismos atributos lógicos.
Por ejemplo, todas las particiones comparten la misma columna y las mismas definiciones de constraint.

Ejemplo

CREATE TABLE stock_xactions


(stock_simbol CHAR(5),
stock_series CHAR(1),
num_shares NUMBER(10),
price NUMBER(5, 2),
trade_date DATE)
STORAGE (INITIAL 100K NEXT 50K) LOGGING
PARTITION BY RANGE (trade_date)
(PARTITION sx1992 VALUES LESS THAN (TO_DATE (‘01-JAN-1993’, ‘DD-MON-YYYY’))
TABLESPACE ts0 NOLOGGING,
PARTITION sx1993 VALUES LESS THAN (TO_DATE (‘01-JAN-1994’, ‘DD-MON-YYYY’))
TABLESPACE ts1,
PARTITION sx1994 VALUES LESS THAN (TO_DATE (‘01-JAN-1995’, ‘DD-MON-YYYY’))
TABLESPACE ts2);

4.1.32.3 Tablas de objetos

Ejemplo

CREATE TYPE dept_t SA OBJECT


(dname VARCHAR2(100),
address VARCHAR2(200));

CREATE TABLE dept OF dept_t;

4.1.33 CREATE TABLESPACE

Se utiliza para crear un espacio de tablas. Un espacio de tablas es un espacio de la base de


datos que puede contener objetos estructurados. Para poder crear un espacio de tablas es necesario el
privilegio CREATE TABLESPACE. La sintaxis es la siguiente:

Sql_manual.doc 86
MANUAL DE SQL

CREATE TABLESPACE tablespace DATAFILE [opciones];

Para saber más acerca de las opciones consultar un manual.

Un espacio de tablas es un espacio en la base de datos que puede contener cualquiera de los
siguientes objetos:

Segmentos de datos.
Segmentos de índices.
Segmentos rollback.
Segmentos temporales.

Todas las bases de datos tienen como mínimo un espacio de tablas, SYSTEM, que se crea
automáticamente cuando se crea la base de datos.

Ejemplo
CREATE TABLESPACE tabspace_3
DATAFILE ‘tabspace_file5.dbf’ SIZE 2M
MINIMUN EXTENT 64K
DEFAULT STORAGE (INITIAL 128K NEXT 128K)
LOGGING;

4.1.34 CREATE TRIGGER

Se utiliza para crear y habilitar un disparador (trigger) de la base de datos. Un disparador de la


base de datos es un bloque PL/SQL almacenado que está asociado con una tabla.

Antes de poder crear un disparador el usuario sys, debe ejecutar el script DBMSSTDX.SQL.
Para crear un disparador se necesitan los privilegios CREATE TRIGGER o CREATE ANY TRIGGER,
según lo creemos en nuestro propio esquema o no. La sintaxis es la siguiente:

CREATE [OR REPLACE] TRIGGER trigger {BEFORE | AFTER | INSTEAD OF}


{ OR | DELETE | INSERT | UPDATE [OF column] }
ON [schema.] {TABLE | VIEW}
[[REFERENCING [{OLD [AS] old | NEW [AS] new}]] FOR EACH {ROW | STATEMENT}]
[WHEN (condition)] pl_sql_block ;

4.1.34.1 Uso de los disparadores

Oracle ejecuta automáticamente los disparadores. Se usan los disparadores por alguna de las
siguientes razones:

Para proporcionar una mayor transparencia a los eventos.


Para generar automáticamente los valores derivados de las columnas.
Para reforzar y completar la seguridad en las autorizaciones.

Un disparador se puede encontrar en alguno de los estados siguientes:

Habilitado.
Deshabilitado.

Sql_manual.doc 87
MANUAL DE SQL

Cuando se crea un disparador por defecto se encuentra habilitado.

4.1.34.2 Predicados condicionales

Los disparadores dependen en gran manera de los predicados condicionales con los que los
definamos. Los predicados condicionales que se evalúan son los siguientes:

INSERTING. Retorna verdadero si el trigger se ha disparado por una instrucción INSERT.


DELETING. Retorna verdadero si el trigger se ha disparado por una instrucción DELETE.
UPDATING. Retorna verdadero si el trigger se ha disparado por una instrucción UPDATE.
UPDATING (nombre_columna). Retorna verdadero si el trigger se ha disparado por una
instrucción UPDATE o la columna especificada es modificada.

4.1.34.3 Partes de un disparador

Las instrucciones que provocan que se dispare un trigger son las siguientes: DELETE, INSERT,
UPDATE y ON.

4.1.34.4 Tipos de disparadores

Se pueden crear distintos tipos de disparadores. Los tipos de disparadores determinan:

Oracle dispara el trigger cuando sucede la instrucción con la cual está relacionada.
Cuantas veces dispara Oracle el trigger.

Hay cuatro tipos de disparadores:

Antes de la instrucción de disparo. Oracle dispara el trigger antes de que se ejecute la


instrucción que dispara el trigger.
Antes del disparo del registro. Oracle dispara el trigger antes de modificar cada registro
afectado por la instrucción de disparo del trigger.
Después de la instrucción de disparo. Oracle dispara el trigger después de que se ejecute la
instrucción que dispara el trigger.
Después del disparo de registro. Oracle dispara el trigger después de modificar cada registro
afectado por la instrucción de disparo del trigger.

Ejemplo

CREATE TRIGGER scott.emp_permit_changes


BEFORE DELETE OR INSERT OR UPDATE
ON scott.emp
DECLARE
Dummy INTEGER
BEGIN
/* Si hoy es sábado o domingo retorna un error */
IF (TO_CHAR (SYSDATE, ‘DY’) = ‘SAT’ OR
TO_CHAR (SYSDATE’, ‘DY’) = ‘SUN’)
THEN raise_application_error ( -20501,
‘No se puede cambiar la tabla empleados en el fin de semana’);
END IF;

Sql_manual.doc 88
MANUAL DE SQL

/* Compara la fecha de hoy con las fechas de vacaciones de la


compañía, si es un día de vacaciones de la compañía retorna un error */
SELECT COUNT (*)
INTO dummy
FROM company_holidays
WHERE day = TRUNC (SYSDATE);
IF dummy > 0
THEN raise application_error ( -20501, ‘No se pueden hacer
cambios en la tabla empleados un día de vacaciones’);
END IF;
/* Si la hora actual es antes de las 8:00 am o después de las
6:00 pm devuelve un error */
IF (TO_CHAR (SYSDATE, ‘HH24’) < 8 OR
TO_CHAR(SYSDATE, ‘HH24’) > = 18)
THEN raise_application_error ( -20501, ‘ Solo se pueden realizar
Cambios en la tabla empleados en las horas de trabajo’);
END IF;
END;

4.1.35 CREATE TYPE

Se utiliza para crear un tipo de objeto, como puede ser un VARRAY. Para poder crear un tipo es
necesario tener los privilegios CREATE TYPE o CREATE ANY TYPE, según creemos el tipo en nuestro
esquema o en otro distinto. La sintaxis es la siguiente:

CREATE [OR REPLACE] TYPE [schema.] type_name ;

Además hay una serie de opciones, para conocer más acerca de ellas consultar un manual.

Ejemplo

CREATE TYPE foo AS OBJECT (a1 NUMBER,


MEMBER FUNCTION getbar RETURN NUMBER,
Pragma RESTRICT_REFERENCES (getbar, WNDS, WNPS));

CREATE TABLE footab (col foo);

SELECT col.getbar () FROM footab;

4.1.36 CREATE TYPE BODY

Se utiliza para definir o implementar los métodos definidos en la especificación del tipo. Es
necesario tener los privilegios CREATE TYPE o CREATE ANY TYPE. La sintaxis es la siguiente:

CREATE [OR REPLACE] TYPE BODY [schema.] type_name [opciones];

Para saber más acerca de las opciones consultar un manual.

Sql_manual.doc 89
MANUAL DE SQL

Ejemplo

CREATE TYPE BODY rational IS


MAP MEMBER FUNCTION rat_to_real RETURN REAL IS
BEGIN
RETURN numerator/denominator;
END;

MEMBER PROCEDURE normalize IS


Gcd INTEGER := integer_operations.greatest_common_divisor
(numerator, denominator);
BEGIN
Numerator := numerator/gcd;
Denominator := denominator/gcd;
END;

MEMBER FUNCTION plus (x rational) RETURN rational IS


R rational := rational_operations.make_rational
(numerator*x.denominator + x.numerator*denominator,
denominator*x.denominator);
BEGIN
RETURN r;
END;
END;

4.1.37 CREATE USER

Se utiliza para crear un usuario de la base de datos. Se pueden asignar las siguientes
propiedades opcionales a un usuario:

El espacio de tablas por defecto.


El espacio de tablas temporal.
Los recursos de los que puede disponer.

Para poder crear un usuario es necesario el privilegio CREATE USER. La sintaxis es la


siguiente:

CREATE USER user IDENTIFIED {BY password | EXTERNALLY |


GLOBALLY AS ‘external_name’} [opciones];

Para saber más acerca de las opciones consultar un manual.

Ejemplo

CREATE USER ops$george


IDENTIFIED EXTERNALLY
DEFAULT TABLESPACE accs_ts
TEMPORALLY TABLESPACE temp_ts
QUOTA UNLIMITED ON accs_ts
QUOTA UNLIMITED ON temp_ts;

Sql_manual.doc 90
MANUAL DE SQL

4.1.38 CREATE VIEW

Se utiliza para crear una vista, que es una tabla lógica basada en una o más tablas y vistas. Para
poder crear una vista son necesarios los privilegios CREATE VIEW o CREATE ANY VIEW, según
creemos la vista en nuestro propio esquema o en otro esquema. Cuando se crea una vista uno de los
siguientes estamentos ha de ser cierto:

El objeto relacionado con la vista se tiene que encontrar en el mismo esquema que la vista.
Hay que tener el privilegio EXECUTE ANY TYPE.
Hay que tener el privilegio EXECUTE del objeto de la vista,

La sintaxis es la siguiente:

CREATE [OR REPLACE] [[NO] FORCE] VIEW [schema.] view [opciones];

Para saber más acerca de las opciones consultar un manual.

4.1.38.1 Uso de las vistas

Una vista es una tabla lógica que permite el acceso a datos de otras tablas o vistas. Una vista no
contiene datos. Las vistas son usadas por alguno de las siguientes razones:

Para proveer de un nivel adicional de seguridad a la tabla.


Para presentar los datos desde otra perspectiva.
Para depurar algunas operaciones de Oracle.

4.1.38.2 Consulta de una vista

A la hora de crear una vista hay que tener en cuenta:

La consulta de una vista no puede seleccionar las pseudocolumnas NEXTVAL y CURRVAL..


Se puede crear una vista en la que la consulta utilice el asterisco (*).
Se pueden crear vistas que se refieran a tablas remotas.

Una vista no puede realizar ni inserciones ni modificaciones ni puede borrar, a no ser que lo
haga mediante los disparadores. Una vista puede contener los siguientes comandos:

Operadores Set.
Funciones agrupadas.
Las cláusulas GROUP BY, CONNECT BY o START WITH.
El operador DISTINCT.
Joins.

Ejemplo 1

CREATE VIEW ed AS
SELECT e.empno, e.ename, d.deptno, d.loc
FROM emp e, dept d
WHERE e.deptno = d.deptno

Sql_manual.doc 91
MANUAL DE SQL

View created

SELECT column_name, updatable


FROM user_updatable_columns
WHERE table_name = ‘ED’;

COLUMN_NAME UPD
--------------- ----
ENAME YES
DEPTNO NO
EMPNO YES
LOC NO

Ejemplo 2

CREATE TYPE employee_type AS OBJECT


(empno NUMBER(4),
ename VARCHAR2(20),
job VARCHAR2(9),
mgr NUMBER(4),
hiredate DATE,
sal NUMBER(7, 2),
comm NUMBER(7, 2));

CREATE OR REPLACE VIEW emp_object_view OF employee_type


WITH OBJECT OID (empno)
AS SELECT empno, ename, job, mgr, hiredate, sal, comm
FROM emp;

4.1.39 Cláusula DISABLE

Se utiliza para deshabilitar una constraint de integridad o todos los disparadores asociados con
una tabla. Para poder ejecutar este comando es necesario tener los privilegios CREATE TABLE o
CREATE ANY TABLE. La sintaxis es la siguiente:

DISABLE { ALL TRIGGERS |


{ CONSTRAINT constraint | PRIMARY KEY | UNIQUE (column)} [CASCADE] }};

Si se deshabilita una constraint PRIMARY KEY o UNIQUE, Oracle borra el índice relacionado
con la constraint. Si una constraint PRIMARY KEY o UNIQUE esta relacionada con una foreign key hay
que utilizar la opción CASCADE para deshabilitar también la foreign key.

Ejemplo 1

CREATE TABLE dept


(deptno NUMBER(2) PRIMARY KEY
dname VARCHAR2(10),
loc VARCAHAR2(9) )
DISABLE PRIMARY KEY;

Ejemplo 2

Sql_manual.doc 92
MANUAL DE SQL

ALTER TABLE customers


DISABLE UNIQUE (areaco, phoneno) CASCADE;

4.1.40 Cláusula DROP

Se utiliza para borrar una constraint de integridad de la base de datos. Es necesario tener el
privilegio ALTER TABLE en la tabla sobre la que se va a trabajar. La sintaxis es la siguiente:

DROP { CONSTRAINT constraint |


{ UNIQUE (column) | PRIMARY } [CASCADE] };

Cuando se borra una constraint de integridad, Oracle la borra del diccionario de datos y ya no se
puede recuperar. La opción CASCADE se utiliza para borrar todas las foreign key que están relacionadas
con la constraint.

Ejemplo

ALTER TABLE dept


DROP PRIMARY KEY CASCADE;

4.1.41 DROP CLUSTER

Se utiliza para borrar un cluster de la base de datos. Para poder borrar el cluster, este se debe
encontrar en nuestro propio esquema o tener el privilegio DROP ANY CLUSTER. La sintaxis es la
siguiente:

DROP CLUSTER [schema.] cluster [INCLUIDING TABLES [CASCADE CONSTRAINTS]];

Cuando se borra un cluster también se borra el índice del cluster y se recupera todo es espacio
que ocupaba el cluster.

Ejemplo

DROP CLUSTER geography


INCLUIDING TABLES
CASCADE CONSTRAINTS;

4.1.42 DROP DATABASE LINK

Se utiliza para borrar un enlace a base de datos de la base de datos. Es necesario tener el
privilegio DROP PUBLIC DATABASE LINK. La sintaxis es la siguiente:

DROP [PUBLIC] DATABASE LINK dblink;

Ejemplo

DROP DATABASE LINK boston;

Sql_manual.doc 93
MANUAL DE SQL

4.1.43 DROP FUNCTION

Se utiliza para borrar una función almacenada de la base de datos. Para poder borrar la función,
esta se debe encontrar en nuestro propio esquema o tener el privilegio DROP ANY PROCEDURE. La
sintaxis es la siguiente:

DROP FUNCTION [schema.] function;

Para borrar una función que se encuentra dentro de un paquete es necesario borrar el paquete y
volver a crearlo sin definir la función.

Ejemplo

DROP FUNCTION riddley.new_accr;

4.1.44 DROP INDEX

Se utiliza para borrar un índice de la base de datos. Para poder borrar un índice, este se debe
encontrar en nuestro propio esquema o tener el privilegio DROP ANY INDEX. La sintaxis es la siguiente:

DROP INDEX [schema.] index;

Ejemplo
DROP INDEX monolith;

4.1.45 DROP PACKAGE

Se utiliza para borrar un paquete almacenado en la base de datos. Para poder borrar un
paquete, este se debe encontrar en nuestro propio esquema o tener el privilegio DROP ANY
PROCEDURE. La sintaxis es la siguiente:

DROP PROCEDURE [BODY] [schema.] package;

Cuando se borra todo el paquete incluyendo el cuerpo, también se borran los objetos que están
definidos en el paquete, pero si no se borra el cuerpo entonces los objetos no se borran, aunque no
pueden ser llamados.

Ejemplo

DROP PROCEDURE kerner.transfer;

4.1.46 DROP ROLE

Se utiliza para borrar un role de la base de datos. Para poder borrar un role hay que tener el role
ADMIN OPTION o el privilegio DROP ANY ROLE. La sintaxis es la siguiente:

DROP ROLE role;

Ejemplo

DROP ROLE florist;

Sql_manual.doc 94
MANUAL DE SQL

4.1.47 DROP ROLLBACK SEGMENT

Se utiliza para borrar un segmento rollback de la base de datos. Para poder borrarlo es
necesario tener el privilegio DROP ROLLBACK SEGMENT. La sintaxis es la siguiente:

DROP ROLLBACK SEGMENT rollback_segment;

No se puede borrar el segmento rollback del sistema SYSTEM.

Ejemplo

DROP ROLLABCK SEGMENT accounting;

4.1.48 DROP SEQUENCE

Se utiliza para borrar una secuencia de la base de datos. Para poder borrar una secuencia, esta
se debe encontrar en nuestro propio esquema o tener el privilegio DROP ANY SEQUENCE. La sintaxis
es la siguiente:

DROP SEQUENCE [schema.] sequenece;

Ejemplo

DROP SEQUENCE ally.eseq;DROP SYNONYM

Se utiliza para borrar un sinónimo de la base de datos. Para poder borrar un sinónimo, este se
tiene que encontrar en nuestro propio esquema o tener el privilegio DROP ANY SYNONYM o DROP ANY
PUBLIC SYNONYM. La sintaxis es la siguiente:

DROP [PUBLIC] SYNONYM [schema.] synonym;

Ejemplo

DROP SYNONYM market;

4.1.49 DROP TABLE

Se utiliza para borrar una tabla y todos sus datos de la base de datos. Para poder borrar una
tabla, esta se tiene que encontrar en nuestro propio esquema o tener el privilegio DROP ANY TABLE. La
sintaxis es la siguiente:

DROP TABLE [schema.] table [CASCADE CONSTRAINTS];

Cuando se borra una tabla, Oracle realiza automáticamente lo siguiente:


Oracle borra todos los registros de la tabla.
Oracle borra todos los índices de la tabla.
Si a la tabla la hacen referencia otros objetos como vistas, funciones, procedimientos, etc.,
estos objetos no pueden ejecutarse pero no se borran.
Con la opción CASCADE CONSTRAINTS se borran todos las constraints foreign key que
hagan referencia a la constraint de la tabla.

Ejemplo

Sql_manual.doc 95
MANUAL DE SQL

DROP TABLE test_data;

4.1.50 DROP TABLESPACE

Se utiliza para borrar un espacio de tablas de la base de datos. Para poder borrar un espacio de
tablas es necesario tener el privilegio DROP TABLESPACE. La sintaxis es la siguiente:

DROP TABLESPACE tablespace [INCLUIDING CONTENTS [CASCADE CONSTRAINTS]];

No se puede borrar el espacio de tablas SYSTEM.


Ejemplo

DROP TABLESPACE mfmt


INCLUIDING CONTENTS
CASCADE CONSTRAINTS;

4.1.51 DROP TRIGGER

Se utiliza para borrar un disparador de la base de datos. Para poder borrar un disparador, este
se debe encontrar en nuestro propio esquema o tener el privilegio DROP ANY TRIGGER. La sintaxis es
la siguiente:

DROP TRIGGER [schema.] trigger;

Ejemplo

DROP TRIGGER ruth.reorder;

4.1.52 DROP TYPE

Se utiliza para borrar la especificación y el cuerpo de un objeto (VARRAY). Para poder borrar un
objeto, este tiene que encontrarse en nuestro propio esquema o tener el privilegio DROP ANY TYPE. La
sintaxis es la siguiente:

DROP TYPE [schema.] type_name [FORCE];

Ejemplo

DROP TYPE person_t;

4.1.53 DROP TYPE BODY

Se utiliza para borrar el cuerpo de un objeto. Para poder borrar un objeto, este tiene que
encontrarse en nuestro propio esquema o tener el privilegio DROP ANY TYPE. La sintaxis es la siguiente:

DROP TYPE BODY [schema.] type_name;

Si solo borramos el cuerpo del objeto, la especificación todavía existe y se puede reutilizar.

Ejemplo

Sql_manual.doc 96
MANUAL DE SQL

DROP TYPE BODY rational;

4.1.54 DROP USER

Se utiliza para borrar un usuario de la base de datos, y opcionalmente todos los objetos del
usuario. Para poder borrar un usuario es necesario tener el privilegio DROP USER. La sintaxis es la
siguiente:

DROP USER user [CASCADE];

Ejemplo
DROP USER bradley CASCADE;

4.1.55 DROP VIEW

Se utiliza para borrar una vista. Para poder borrar una vista, esta se tiene que encontrar en
nuestro propio esquema o tener el privilegio DROP ANY VIEW. La sintaxis es la siguiente:

DROP VIEW [schema.] view;

Ejemplo
DROP VIEW view_data;

4.1.56 Cláusula ENABLE

Se utiliza para habilitar una constraint de integridad o todos los disparadores asociados a una
tabla. Para poder utilizar este comando es necesario tener los privilegios CREATE TABLE, ALTER
TABLE y CREATE INDEX. La sintaxis es la siguiente:

ENABLE { ALL_TRIGGERS |
[{ VALIDATE | NOVALIDATE }] { UNIQUE (column) |
PRIMARY KEY | CONSTRAINT constraint },
[using_index_clause], [exceptions_clause] };

Ejemplo 1

CREATE TABLE orders


(ord_num NUMBER PRIMARY KEY,
ord_quantity NUMBER) ORGANIZATION INDEX;

EXECUTE DBMS_IOT.BUILT_EXCEPTIONS_TABLE
(‘SCOTT’, ‘ORDERS’, ‘ORDER_EXCEPTIONS’);

ALTER TABLE orders


ADD CONSTRAINT CHECK_ORDERS CHECK (ord_quenatity > 0)
EXCEPTIONS INTO ORDER_EXCEPTIONS;

Ejemplo 2

ALTER TABLE emp

Sql_manual.doc 97
MANUAL DE SQL

ENABLE ALL TRIGGERS;

4.1.57 GRANT (privilegios del sistema y roles)

Se utiliza para asignar privilegios y roles a los usuarios y a los roles. Para poder utilizar este
comando es necesario disponer de alguno de los siguientes privilegios ADMIN OPTION, GRANT ANY
PRIVILEGE o GRANT ANY ROLE. La sintaxis es la siguiente:

GRANT { system_priv | role } TO { user | role | PUBLIC } [WITH ADMIN OPTION] ;

Cuando se asigna un privilegio o un role a PUBLIC, Oracle lo añade al dominio de privilegios de


cada usuario. A la hora de asignar privilegios y roles hay que tener en cuenta las siguientes restricciones:

No se puede asignar un role a uno mismo.


No se puede asignar el role IDENTIFIED GLOBALLY.
No se puede asignar el role IDENTIFIED EXTERNALLY a un usuario global o a un role.
No se pueden asignar roles circularmente.

Ejemplo 1

GRANT CREATE TABLE


TO travel_agent;

Ejemplo 2

GRANT executive TO Thomas


WITH ADMIN OPTION;K

4.1.58 GRANT (privilegios a objetos)

Se utiliza para asignar privilegios a objetos. La sintaxis es la siguiente:

GRANT { ALL [PRIVILEGES] | object_priv } [(column)]


ON [{ DIRECTORY directory_object | schema.object }] TO {user | role | PUBLIC};

La siguiente tabla muestra los privilegios que se pueden asignar a cada tipo de objeto.

TABL VISTA SECUENCIA FUNCIONES, PROCEDIMIENTOS DIRECTORIOS


A Y PAQUETES. .
ALTER X X
DELETE X X
EXECUTE X
INDEX X
INSERT X X
READ X
REFERENCE X
S
SELECT X X X
UPDATE X X

Sql_manual.doc 98
MANUAL DE SQL

Ejemplo 1

GRANT READ ON DIRECTORY bfile_dir1 TO scott


WITH GRANT OPTION;

Ejemplo 2

GRANT REFERENCES (empno), UPDATE (empno, sal, comm)


ON scott TO blake;

4.1.59 RENAME

Se utiliza para renombrar una tabla, una vista, una secuencia o un sinónimo privado. Para poder
ejecutar este comando es necesario que el objeto se encuentre en nuestro esquema. La sintaxis es la
siguiente:

RENAME old TO new;

Las constraints de integridad, los índices y los permisos del objeto antiguo son transferidos
automáticamente al nuevo objeto. Oracle invalida todos los objetos que dependen del objeto que se ha
renombrado, como pueden ser vistas, sinónimos y funciones y procedimientos almacenados.

No se puede utilizar este comando para renombrar sinónimos públicos.

Ejemplo

RENAME dept TO emp_dept;

4.1.60 REVOKE (privilegios del sistema y roles)

Se utiliza para revocar los privilegios del sistema y los roles a usuarios o roles. Es necesario
tener el privilegio GRANT ANY ROLE para poder ejecutar este comando. La sintaxis es la siguiente:

REVOKE { system_priv | role} FROM {user | role | PUBLIC};

El comando REVOKE solo puede revocar los privilegios o roles que han sido asignados por
medio del comando GRANT.

Ejemplo

REVOKE CREATE ANY TABLE FROM scott;

4.1.61 REVOKE (privilegios de objetos)

Se utiliza para revocar privilegios de un objeto. Solo se podrán revocar los privilegios que hayan
sido asignados anteriormente con el comando GRANT. La sintaxis es la siguiente:

REVOKE {object_priv | ALL [PRIVILEGES]} ON {[schema.] object | DIRECTORY directory_object}

Sql_manual.doc 99
MANUAL DE SQL

FROM {user | role | PUBLIC} [CASCADE CONSTRAINTS] [FORCE];

La opción FORCE hace que los datos que se encuentran en las tablas dependientes sean
inaccesibles. La opción CASCADE CONSTRAINTS revoca todas las referencias que hay.

Ejemplo 1

REVOKE ALL ON bonus FROM pedro;

Ejemplo 2

REVOKE SELECT ON elly.eseq FROM blake;

4.1.62 SUBQUERIES

Una subquery (subconsulta) es cuando una consulta mediante la instrucción SELECT aparece
dentro de otra instrucción SQL. A veces una subconsulta se denomina nested query. La sintaxis es la
siguiente:

SELECT [{DISTINT | ALL}] [{ expr [[AS] c_alias] |


‘ [schema.] {table | view}’}]
FROM {TABLE (nested_table_column) |
{[THE] (subquery [with clause]) |
[schema.] {view [@dblink] |
table [{@dblink | PARTITION (partition_name) }] }}
[t_alias]} [WHERE condition] , [{GROUP BY expr , [HAVING condition] |
[START WITH condition] CONNECT BY condition}]
[{UNION [ALL] | INTERSECT | MINUS} (subquery)]

4.1.62.1 Uso de las subqueries

Se utilizan las subqueries por alguna de las siguientes razones:

Para definir el conjunto de registros que deben ser introducidos en una tabla mediante las
instrucciones INSERT o CREATE TABLE.
Para definir el conjunto de registros que deben ser incluidos en una vista mediante la
instrucción CREATE VIEW.
Para definir uno o más valores que se van a asignar a unos registros que ya existen
mediante la instrucción UPDATE.
Para proveer valores para las condiciones en las cláusulas WHERE, HAVING y START
WITH de las instrucciones SELECT, UPDATE y DELETE.

Una subquery solo se evalúa una vez por toda la instrucción padre (la instrucción que contiene la
subquery), mientras que las subqueries anidadas se evalúan una vez por cada registro procesado por la
instrucción padre.

Ejemplo

SELECT ename, deptno

Sql_manual.doc 100
MANUAL DE SQL

FROM emp
WHERE deptno =
(SELECT deptno FROM emp WHERE ename = ‘TAYLOR’);

4.1.62.2 Subqueries anidadas

La instrucción padre puede ser una de instrucción SELECT, UPDATE o DELETE. Los ejemplos
que hay a continuación muestran la sintaxis de una subquery:

SELECT select_list
FROM table1 t_alias1
WHERE expr operator
(SELECT column_list
FROM table2 t_alias2
WHERE t_alias1.column operator t_alias2.column);

UPDATE select_list
SET column
(SELECT expr
FROM table2 t_alias2
WHERE t_alias1.column operator t_alias2.column);

DELETE FROM table1 t_alias1


WHERE column operator
(SELECT expr
FROM table2 t_alias2
WHERE t_alias1.column operator t_alias2.column);

Ejemplo

SELECT deptno, ename, sal


FROM emp x
WHERE sal > (SELECT AVG(sal)
FROM emp
WHERE x.deptno = deptno)
ORDER BY deptno;

4.2 Comandos DML (Data Manipulation Language)

Los comandos DML realizan consultas y manipulan los datos existentes en los objetos. Estos
comandos no actualizan implícitamente la transacción.

Sql_manual.doc 101
MANUAL DE SQL

4.2.1 DELETE

Se utiliza para borrar datos de una tabla o de una vista basada en una tabla. Para poder borrar
los datos de una tabla es necesario tener el privilegio DELETE sobre esa tabla. La sintaxis es la siguiente:

DELETE FROM [schema.] { table | view } [opciones];

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1

DELETE FROM (select * from emp)


WHERE JOB = ‘SALESMAN’
AND COMM < 100;

Ejemplo 2

DELETE THE (SELECT projs


FROM dept d WHERE d.dno = 123) AS P
WHERE p.pno IN (123, 456) OR p.budgets >456.78;k

4.2.2 EXPLAIN PLAN

Se utiliza para determinar el plan de ejecución de Oracle. Este comando inserta un registro
describiendo cada paso del plan de ejecución en una tabla específica. Para poder ejecutar este comando
es necesario tener los privilegios necesarios para poder insertar en una tabla. La sintaxis es la siguiente:

EXPLAIN PLAN [SET STAMENT_ID – ‘text’] [INTO [schema.] table] FOR stament;

No se puede utilizar el comando EXPLAIN PLAN para determinar los planes de ejecución de
instrucciones que accedan al diccionario de datos. Se puede utilizar este comando como parte de SQL
Trace.

Ejemplo

EXPLAIN PLAN
SET STATEMENT_ID = ‘Raise in Chicago’
INTO output
FOR UPDATE emp
SET sal = sal * 1.10
WHERE deptno = (SELECT deptno FROM dept WHERE loc = ‘CHICAGO’);

La siguiente operación realiza una consulta a la tabla OUTPUT y devuelve el plan de ejecución.

SELECT LPAD (‘ ‘, 2*(LEVEL-1)) || operation operation, options, object_name, position


FROM output
START WITH id = 0 AND statement_id = ‘Raise in Chicago’
CONNECT BY PRIOR id = parent_id AND statement_id = ‘Raise in Chicago’;

La consulta que retorna es la siguiente:

Sql_manual.doc 102
MANUAL DE SQL

OPERATION OPTIONS OBJECT_NAME POSITION


UPDATE STATEMENT 1
FILTER 0
TABLE ACCESS FULL EMP 1
TABLE ACCESS FULL DEPT 2

4.2.3 INSERT

Este comando se utiliza para añadir registros a:

Una tabla.
Una tabla por medio de la vista asociada.
Una partición de una tabla.

Para poder insertar registros en una tabla es necesario que esta se encuentre en nuestro propio
esquema, o tener el privilegio INSERT o INSERT ANY TABLE. La sintaxis es la siguiente:

INSERT INTO {[THE] subquery_1 | [schema.] {view [@dblink] |


Table [{ @dblink | PARTITION (partition_name) }] }} [(column)]
{VALUES (expr) [returning_clause] | subquery_2 } ;

Con la cláusula VALUES se inserta un único registro, pero si esta realizado sobre una consulta,
se insertan tantos registros como devuelva la consulta.

Se pueden insertar registros en una tabla de dos maneras diferentes, son las siguientes:

1 INSERT INTO emp (empno, ename, job, sal, comm, deptno)


VALUES (7890, ‘JINKS’, ‘CLERK’, 1.2E3, NULL, 40);

2 INSERT INTO emp (7890, ‘JINKS’, ‘CLERK’, 1.2E3, NULL, 40);

La diferencia es que de la segunda forma hay que introducir todos los campos en el mismo orden
con el que se creo la tabla, y de la primera forma se introducen en el orden que se especifique en la lista
que hay a continuación del nombre de la tabla, de esta primera forma podemos dejar campos sin rellenar,
siempre y cuando estos campos permitan nulos.

Ejemplo 1

INSERT INTO bonus


SELECT ename, job, sal, comm
FROM emp
WHERE comm > 0.25 * sal OR job IN (‘PRESIDENT’, ‘MANAGER’);

Ejemplo 2

INSERT INTO employee


VALUES (‘Kitty Mine’, ‘Peaches Fuzz’, ‘Meena Katz’)
RETURNING REF (employee) INTO :1;

Sql_manual.doc 103
MANUAL DE SQL

4.2.4 SELECT

Se utiliza para recibir datos de una o más tablas, objetos de una tabla, vistas y objetos de una
vista. Para poder ejecutar este comando es necesario que el objeto se encuentre en nuestro propio
esquema o tener el privilegio SELECT sobre el objeto. La sintaxis es la siguiente:

SELECT [{DISTINT | ALL}] [{ expr [[AS] c_alias] |


‘ [schema.] {table | view}’}]
FROM {[THE] (subquery [with clause]) |
[schema.] {view [@dblink] |
table [{@dblink | PARTITION (partition_name) }] }}
[t_alias] [WHERE condition] , [{GROUP BY expr , [HAVING condition] |
[START WITH condition] CONNECT BY condition}]
[{UNION [ALL] | INTERSECT | MINUS} SELECT comand]
[{FOR UPDATE [OF [[schema.] {table | view} column]] , [NOWAIT] |
ORDER BY {expr | position | c_alias} , [{ASC | DESC}] }];

Para conocer más acerca de cada una de las posibles opciones consultar un manual.

4.2.4.1 Creación de consultas simples

Cada expresión expr es el nombre de una o más columnas, si en expr se pone *, la consulta se
realiza sobre todos los campos (columnas) de la tabla o vista.

Se pueden crear alias (t_alias) de las tablas que se consultan, esto es necesario cuando dos
tablas contienen una columna con el mismo nombre, y es preciso diferenciar la columna de cada una de
las tablas. También se pueden crear alias (c_alias) de los campos sobre los que se va a efectuar la
consulta.

Con la opción DISTINCT la consulta solo devuelve los registros que son distintos, cuando hay
varios registros que son iguales solo devuelve uno de ellos.

Ejemplo 1
SELECT ename, job, sal, deptno
FROM emp
WHERE NOT (job = ‘SALESMAN’ AND deptno = 30);

Ejemplo 2
SELECT a.deptno “Department”,
a.num_emp / b.total_count “%Employees”,
a.sal_num / b.total_sal “%Salary”
FROM
(SELECT deptno, COUNT (*) num_emp, SUM (sal) sal_sum
FROM scott.emp
GROUP BY deptno) a,
(SELECT COUNT(*) total_count, SUM(sal) total_sal
FROM scott.emp) b;

4.2.4.2 Consultas jerárquicas

Sql_manual.doc 104
MANUAL DE SQL

Si una tabla contiene datos de forma jerárquica, se pueden seleccionar registros de forma
jerárquica utilizando las siguientes cláusulas:

START WITH. Especifica el registro raíz de la jerarquía.


CONNECT BY. Especifica las relaciones entre los registros padres y los registros hijos.
WHERE. Restringe los registros que retorna la consulta.

Oracle para usar las cláusulas mencionadas sigue los siguientes pasos:

1. Oracle selecciona el registro o los registros raíz que cumplan la condición de la cláusula
START WITH.
2. Oracle selecciona los registros hijos de cada uno de los registros raíz. Cada registro hijo
debe cumplir la condición de la cláusula CONNECT BY con el registro padre.
3. Oracle selecciona las generaciones sucesivas de registros hijos. Oracle siempre selecciona
los registros hijos que cumplan la condición de la cláusula CONNECT BY con su registro
padre.
4. Si la consulta contiene la cláusula WHERE, Oracle elimina todos los registros que no
cumplan la condición de la cláusula WHERE. Oracle evalúa está condición para cada uno de
los registros.
5. Oracle retorna los registros.

CLÁUSULA START WITH

Esta cláusula identifica los registros que se van a tomar como registros raíz de la jerarquía. Esta
cláusula especifica una condición que deben cumplir los registros raíz. Si se omite esta cláusula todos los
registros de la tabla son registros raíz. Una condición START WITH puede contener una subconsulta.

CLÁUSULA CONNECT BY

Esta cláusula especifica las relaciones entre el registro padre y los registros hijo. Esta cláusula
contiene una condición que define esta relación. En alguna parte de la condición se puede usar el
operador PRIOR para referirse al registro padre. La parte de la condición que contiene el operador
PRIOR tiene una de las siguientes formas:

PRIOR expr comparision_operator expr


Expr comparision_operator PRIOR expr

Los registros que cumplen la condición son los registros hijo del registro padre. Esta cláusula no
puede contener subconsultas.

Si esta cláusula cae en un bucle Oracle retorna un error.

Ejemplo

CONNECT BY PRIOR empno = mgr AND sal > comm;

PSEUDOCOLUMNA LEVEL

LEVEL retorna el valor 1 para el nodo raíz, 2 para los nodos hijos del nodo raíz, y así
sucesivamente.

Sql_manual.doc 105
MANUAL DE SQL

Ejemplo 1

SELECT LPAD (‘ ‘, 2*(LEVEL-1)) || ename org_chart, empno, mgr, job


FROM emp
START WITH job = ‘PRESIDENT’
CONNECT BY PRIOR empno = mgr;

ORG_CHAR EMPNO MGR JOB


----------- ------- ----- ----
KING 7839 PRESIDENT
JONES 7566 7839 MANAGER
SCOTT 7788 7566 ANALYST
ADAMS 7876 7788 CLERK
FORD 7902 7566 ANALYST
SMITH 7369 7902 CLERK
BLAKE 7698 7839 MANAGER
ALLEN 7499 7698 SALESMAN
WARD 7521 7698 SALESMAN
MARTIN 7654 7698 SALESMAN
TURNER 7844 7698 SALESMAN
JAMES 7900 7844 CLERK
CLARK 7782 7839 MANAGER
MILLER 7934 7782 CLERK

Ejemplo 2

SELECT LPAD (‘ ‘, 2*(LEVEL-1)) || ename org_chart, empno, mgr, job


FROM emp
START WITH job = ‘PRESIDENT’
CONNECT BY PRIOR empno = mgr AND LEVEL <= 2;

ORG_CHAR EMPNO MGR JOB


----------- ------- ----- ----
KING 7839 PRESIDENT
JONES 7566 7839 MANAGER
BLAKE 7698 7839 MANAGER
CLARK 7782 7839 MANAGER

4.2.4.3 CLÁUSULA GROUP BY

Esta cláusula se utiliza para agrupar una selección de registros. Oracle hace la colección de
cada grupo de registros basándose en el valor de la expresión o expresiones especificadas en la cláusula
GROUP BY.

Si una instrucción SELECT contiene la cláusula GROUP BY, la lista de selección solo puede
contener los siguientes tipos de expresiones:

Constantes.
Funciones agrupadas.
Las funciones USER, UID y SYSDATE.

Sql_manual.doc 106
MANUAL DE SQL

La cláusula GROUP BY no puede contener más de 255 expresiones.

Ejemplo
SELECT deptno, MIN (sal), MAX (sal)
FROM emp
WHERE job = ‘CLERK’
GROUP BY deptno;

DEPTNO MIN (SAL) MAX (SAL)


------- --------- ----------
10 1300 1300
20 800 1100
30 950 950

CLÁUSULA HAVING

Se utiliza la cláusula HAVING para restringir los grupos de registros que se especifican en la
cláusula GROUP BY. El procesamiento que efectúa Oracle con las cláusulas WHERE, GROUP BY y
HAVING es el siguiente:

1. Si la instrucción contiene la cláusula WHERE, Oracle elimina automáticamente todos los


registros que no la cumplen.
2. Oracle calcula y forma los grupos tal y como se especifican en la cláusula GROUP BY.
3. Oracle elimina todos los grupos que no satisfacen la cláusula HAVING.

Hay que especificar las cláusulas GROUP BY y HAVING después de las cláusulas WHERE y
CONNECT BY.

Ejemplo

SELECT deptno, MIN (sal), MAX (sal)


FROM emp
WHERE job = ‘CLERK’
GROUP BY deptno
HAVING MIN (sal) < 1000;

DEPTNO MIN (SAL) MAX (SAL)


------- --------- ----------
20 800 1100
30 950 950

4.2.4.4 UNION, UNION ALL, INTERSECT y MINUS

Los operadores UNION, UNION ALL, INTERSECT y MINUS combinan los resultados de dos
consultas en una única consulta. El número y el tipo de datos de las columnas seleccionadas en cada
consulta deben ser iguales, pero el tamaño de las columnas puede ser diferente.

Si se combinan más de dos consultas con estos operadores, Oracle evalúa por parejas de
consultas, de izquierda a derecha. Se pueden poner paréntesis para especificar el orden de evaluación.

Sql_manual.doc 107
MANUAL DE SQL

4.2.4.5 CLÁUSULA ORDER BY

Se utiliza la cláusula ORDER BY para ordenar los registros seleccionados en una consulta. La
cláusula especifica una expresión, una posición o un alias de una expresión, y Oracle retorna los registros
basándose en los valores de estas expresiones.

Se pueden especificar múltiples expresiones en la cláusula ORDER BY. Los registros con el
mismo valor para la primera expresión se ordenan por el valor de la segunda expresión, y así
continuamente. Si la ordenación es en modo ascendente, Oracle coloca los nulos al final, y si la
ordenación es en modo descendente, Oracle coloca los nulos al principio.

La cláusula ORDER BY tiene las siguientes restricciones:

Si en una instrucción SELECT aparecen conjuntamente el operador DISTINCT y la cláusula


ORDER BY, la cláusula ORDER BY no se puede referir a columnas que no aparezcan en la
lista de selección.
La cláusula ORDER BY no puede aparecer en subconsultas con otras instrucciones.
La cláusula ORDER BY no puede contener más de 255 expresiones.

Ejemplo 1

SELECT ename, deptno, sal


FROM emp
ORDER BY 2 ASC, 3 DESC;

Ejemplo 2

SELECT ename, deptno, sal


FROM emp
ORDER BY deptno ASC, sal DESC;

4.2.4.6 CLÁUSULA FOR UPDATE

La cláusula FOR UPDATE bloquea los registros seleccionados en una consulta. Una vez se ha
seleccionado un registro para modificarlo, los demás usuarios no pueden ni bloquear ni modificar el
registro hasta que quien lo tiene bloqueado no finaliza con él.

La cláusula FOR UPDATE no puede utilizarse con las siguientes construcciones:

El operador DISTINCT.
La cláusula GROUP BY.
Los operadores UNION, UNION ALL, INTERSECT y MINUS.
Las funciones agrupadas.

Las tablas bloqueadas por la cláusula FOR UPDATE se tienen que encontrar todas en la misma
base de datos.

Si un registro que se ha seleccionado para modificar está bloqueado por otro usuario, Oracle
espera hasta que el registro se desbloquea, y luego pasa el control. Se puede utilizar la opción NOWAIT
para que Oracle no espere cuando un registro se encuentre bloqueado.

Ejemplo 1

Sql_manual.doc 108
MANUAL DE SQL

SELECT empno, sal, comm


FROM emp, dept
WHERE job = ‘CLERK’
AND emp.deptno = dept.deptno
AND loc = ‘NEW YORK’
FOR UPDATE;

Ejemplo 2

SELECT empno, sal, comm


FROM emp, dept
WHERE job = ‘CLERK’
AND emp.deptno = dept.deptno
AND loc = ‘NEW YORK’
FOR UPDATE OF emp.sal;

4.2.4.7 Joins

Una join es una consulta que combina registros de dos o más tablas o vistas. Si dos o más de
estas tablas tienen columnas con el mismo nombre es necesario especificar las columnas mediante alias
o indicando cada columna de que tabla es, para que no se produzca ambigüedad.

Condiciones de los joins

Para ejecutar una join, Oracle combina parejas de registros, cada uno de una tabla, para los
cuales la condición que evalúa el join es verdadera.

Para ejecutar un join de tres o más tablas, Oracle primero hace el join de dos de las tablas, y con
la tabla resultante realiza el join con la tercera tabla, en caso de haber más tablas se seguiría haciendo de
la misma manera.

EQUIJOINS

Un equijoin es un join que tiene en su condición un operador de igualdad. Combina registros que
tiene valores equivalentes para las columnas especificadas.

Ejemplo 1

SELECT ename, job, dept.deptno, dname


FROM emp, dept
WHERE emp.deptno = dept.deptno;

ENAME JOB DEPTNO DNAME


------- ---- -------- -------
CLARK MANAGER 10 ACCOUNTING
KING PRESIDENT 10 ACCOUNTING
MILLER CLERK 10 ACCOUNTING
SMITH CLERK 20 RESEARCH
ADAMS CLERK 20 RESEARCH
FORD ANALYST 20 RESEARCH

Sql_manual.doc 109
MANUAL DE SQL

SCOTT ANALYST 20 RESEARCH


JONES MANAGER 20 RESEARCH
ALLEN SALESMAN 30 SALES
BLAKE MANAGER 30 SALES
MARTIN SALESMAN 30 SALES
JAMES CLERK 30 SALES
TURNER SALESMAN 30 SALES
WARD SALESMAN 30 SALES

Ejemplo 2

SELECT ename, job, dept.deptno, dname


FROM emp, dept
WHERE emp.deptno = dept.deptno
AND job = ‘CLERK’;

ENAME JOB DEPTNO DNAME


------- ---- -------- -------
MILLER CLERK 10 ACCOUNTING
SMITH CLERK 20 RESEARCH
ADAMS CLERK 20 RESEARCH
JAMES CLERK 30 SALES

SELF JOINS

Un self join es un join de una tabla consigo misma. Esta tabla aparece dos veces en la cláusula
FROM.

Ejemplo

SELECT e1.ename || ‘ works for ‘ || e2.ename “Employees and their Managers”


FROM emp e1, emp e2
WHERE e1.mgr = e2.empno;

Employees and their Managers

BLAKE works for KING


CLARK works for KING
JONES works for KING
FORD works for JONES
SMITH works for FORD
ALLEN works for BLAKE
WARD works for BLAKE
MARTIN works for BLAKE
SCOTT works for JONES
TURNER works for BLAKE
ADAMS works for SCOTT
JAMES works for BLAKE
MILLER works for CLARK

OUTER JOINS

Sql_manual.doc 110
MANUAL DE SQL

Un outer join devuelve todos los registros que cumplen la condición del join, y aquellos registros
de una de las tablas que no cumplen la condición. Para escribir una consulta que realice un outer join de
las tablas A y B y que retorne todos los registros de A, hay que aplicar el operador (+) para todas las
columnas de B en la condición del join. Todos los registros en A que no se encuentren en B, Oracle
retorna el valor NULL.

La sintaxis básica de un outer join es la siguiente:

SELECT [[table] .column] FROM table1, table2


WHERE table1.column{ (+) table2.column | = table2.column (+)}

Las consultas mediante outer joins están sujetas a las siguientes reglas y restricciones:

El operador (+) solo puede aparecer en la cláusula WHERE, y solo se puede aplicar a una
columna de la tabla o vista.
Si se realizan múltiples condiciones de join entre A y B, el operador (+) se usa en todas las
condiciones.
El operador (+) solo se puede aplicar a una columna, no a una expresión arbitraria.
Una condición que contiene el operador (+) no puede ser combinada con otra condición
mediante el operador lógico OR.
Una condición no puede utilizar el operador IN para comparar con otra expresión que
contenga el operador (+).
Una condición no puede comparar con una subconsulta cualquier columna marcada con el
operador (+).

Ejemplo 1

SELECT ename, job, dept.deptno, dname


FROM emp, dept
WHERE emp.deptno (+) = dept.deptno;

ENAME JOB DEPTNO DNAME


------- ---- -------- -------
CLARK MANAGER 10 ACCOUNTING
KING PRESIDENT 10 ACCOUNTING
MILLER CLERK 10 ACCOUNTING
SMITH CLERK 20 RESEARCH
ADAMS CLERK 20 RESEARCH
FORD ANALYST 20 RESEARCH
SCOTT ANALYST 20 RESEARCH
JONES MANAGER 20 RESEARCH
ALLEN SALESMAN 30 SALES
BLAKE MANAGER 30 SALES
MARTIN SALESMAN 30 SALES
JAMES CLERK 30 SALES
TURNER SALESMAN 30 SALES
WARD SALESMAN 30 SALES
40 OPERATIONS

En este ejemplo el outer join devuelve un registro con el departamento OPERATIONS, a pesar
de que ningún trabajador trabaja en él.

Sql_manual.doc 111
MANUAL DE SQL

Ejemplo 2

A continuación se muestran las tablas sobre las que se van a efectuar los outer joins.

SELECT custno, custname


FROM customers;

CUSTNO CUSTNAME
-------- -----------
1 Angelic Co.
2 Belieable Co.
3 Cabels R Us.

SELECT orderno, custno,


TO_CHAR (orderdate, ‘MON-DD-YYYY’) “ORDERDATE”
FROM orders;

ORDERNO CUSTNO ORDERDATE


--------- -------- ------------
9001 1 OCT-13-1993
9002 2 OCT-13-1993
9003 1 OCT-20-1993
9004 1 OCT-27-1993
9005 2 OCT-31-1993

SELECT orderno, lineno, partno, quantity


FROM lineitems;

ORDERNO LINENO PARTNO QUANTITY


--------- ------- -------- ----------
9001 1 101 15
9001 2 102 10
9002 1 101 25
9002 2 103 50
9003 1 101 15
9004 1 102 10
9004 2 103 20

SELECT partno, partname


FROM parts;

PARTNO PARTNAME
-------- -----------
101 X-Ray Screen
102 Yellow Bag
103 Zoot Suit

El siguiente outer join retorna todos los registros de customers y sus fechas de orders. El
operador (+) fuerza a que los registros de customers que no se encuentren en orders también sean
retornados.

Sql_manual.doc 112
MANUAL DE SQL

SELECT custname, TO_CHAR (orderdate, ‘MON-DD-YYYY’) “ORDERDATE”


FROM customers, orders
WHERE customers.custno = orders.custno (+);

CUSTNAME ORDERDATE
----------- ------------
Angelic Co. OCT-13-1993
Angelic Co. OCT-20-1993
Angelic Co. OCT-27-1993
Belieable Co. OCT-13-1993
Belieable Co. OCT-31-1993
Cables R Us.

El siguiente outer join añade la tabla lineitems a la cláusula FROM.

SELECT custname, TO_CHAR (orderdate, ‘MON-DD-YYYY’) “ORDERDATE”,


Partno, quantity
FROM customers, orders, lineitems
WHERE customers.custno = orders.custno (+)
AND orders.orderno = lineitems.orderno (+);

CUSTNAME ORDERDATE PARTNO QUANTITY


----------- ------------ -------- ----------
Angelic Co. OCT-13-1993 101 15
Angelic Co. OCT-13-1993 102 10
Angelic Co. OCT-20-1993 101 15
Angelic Co. OCT-27-1993 102 10
Angelic Co. OCT-27-1993 103 20
Belieable Co. OCT-13-1993 101 25
Belieable Co. OCT-13-1993 103 50
Belieable Co. OCT-31-1993
Cables R Us.

El siguiente outer join añade la tabla parts a la cláusula FROM.

SELECT custname, TO_CHAR (orderdate, ‘MON-DD-YYYY’) “ORDERDATE”,


Quantity, partname
FROM customers, orders, lineitems, parts
WHERE customers.custno = orders.custno (+)
AND orders.orderno = lineitems.orderno (+)
AND lineitems.partno = parts.partno (+);

CUSTNAME ORDERDATE QUANTITY PARTNAME


----------- ----------- ---------- -----------
Angelic Co. OCT-13-1993 15 X-Ray Screen
Angelic Co. OCT-13-1993 10 Yellow Bag
Angelic Co. OCT-20-1993 15 X-Ray Screen
Angelic Co. OCT-27-1993 10 Yellow Bag
Angelic Co. OCT-27-1993 20 Zoot Suit
Belieable Co. OCT-13-1993 25 X-Ray Screen
Belieable Co. OCT-13-1993 50 Zoot Suit

Sql_manual.doc 113
MANUAL DE SQL

Belieable Co. OCT-31-1993


Cables R Us.

4.2.5 UPDATE

Se utiliza para cambiar los valores de los registros de una tabla. Para poder utilizar esta
expresión es necesario que la tabla se encuentre en nuestro propio esquema, o tener el privilegio
UPDATE sobre la tabla. La sintaxis es la siguiente:

UPDATE {[THE] (subquery_1) | [schema.] {view, @dblink |


Table [{@dblink | PARTITION (partition_name)}]}}
[t_alias] SET {column = {expr | (subquery_2)} |
[(column)] = (subquery_2)}
[WHERE condition], [returning_clause];

4.2.5.1 Modificación de vistas

Si una vista se crea con WITH CHECK OPTION, se puede modificar la vista solo si los datos
resultantes satisfacen la definición de la vista.

No se puede modificar una vista si en su definición contiene alguna de las siguientes


construcciones:

Los operadores UNION, UNION ALL, INTERSECT o MINUS.


La cláusula GROUP BY.
El operador DISTINCT.

4.2.5.2 Modificación de tablas

Ejemplo

UPDATE emp a
SET deptno =
(SELECT deptno
FROM dept
WHERE loc = ‘BOSTON’),
(sal, comm) =
(SELECT 1.1*AVG(sal), 1.5*AVG(comm)
FROM emp b
WHERE a.deptno = b.deptno)
WHERE deptno IN
(SELECT deptno
FROM dept
WHERE loc = ‘DALLAS’
OR loc = ‘DETROIT’);

4.3 Comandos de control de la transacción

Estos comandos manejan los cambios realizados por los comandos DML.

Sql_manual.doc 114
MANUAL DE SQL

4.3.1 COMMIT

Se utiliza para terminar la actual transacción y que todas las modificaciones se hagan
permanentes. La sintaxis es la siguiente:

COMMIT [WORK] [{ COMMENT ‘text’ |


FORCE ‘text’ [.integer] } ;

Ejemplo

INSERT INTO dept VALUES (50, ‘MARKETING’, ‘TAMPA’);


COMMIT WORK;

4.3.2 ROLLBACK

Se utiliza para deshacer el trabajo realizado en una transacción que se está realizando. Para
poder utilizar este comando no hace falta ningún privilegio. La sintaxis es la siguiente:

ROLLBACK [WORK] [{FORCE ‘text’ | TO [SAVEPOINT] savepoint}] ;

Una transacción es una secuencia de instrucciones SQL que Oracle trata como una única unidad.
Una transacción comienza con la primera instrucción SQL ejecutable que hay a continuación de un
COMMIT, ROLLBACK o una conexión a la base de datos. Una transacción termina con el comando
COMMIT, ROLLBACK o una desconexión de la base de datos.

El uso de ROLLBACK sin la cláusula TO SAVEPOINT permite las siguientes operaciones:


Finalizar la transacción.
Deshacer todos los cambios en la transacción que se está realizando.
Borrar todos los savepoint de una transacción.

El uso de ROLLBACK con la cláusula TO SAVEPOINT permite las siguientes operaciones:


Deshacer los cambios de la transacción hasta el último savepoint.

Oracle recomienda que todas las transacciones se terminen con la orden COMMIT o
ROLLBACK.

Ejemplo

ROLLBACK TO SAVEPOINT sp5;

4.3.3 SAVEPOINT

Se utiliza para identificar un punto en una transacción, en el que posteriormente se puede


realizar una vuelta atrás. La sintaxis es la siguiente:

SAVEPOINT savepoint;

Sql_manual.doc 115
MANUAL DE SQL

Los savepoints se utilizan conjuntamente con el comando ROLLBACK. Mediante los savepoints
se consigue un mayor control de los programas. Si se crea un savepoint con el mismo nombre que uno
que ya existe, Oracle borra el más antiguo.
Ejemplo
UPDATE emp
SET sal = 2000
WHERE ename = ‘BLAKE’
SAVEPOINT blake_sal
UPDATE emp
SET sal = 1500
WHERE ename = ‘CLARK’
SAVEPOINT clark_sal
SELECT SUM (sal) FROM emp
ROLLBACK TO SAVEPOINT blake_sal
UPDATE emp
SET sal = 1300
WHERE ename = ‘CLARK’
COMMIT;

4.4 Comandos de control de la sesión

Estos comandos manejan dinámicamente las propiedades de una sesión de usuario. Estos
comandos no actualizan implícitamente las transacciones. PL/SQL no soporta este tipo de comandos.

4.4.1 ALTER SESSION

Se utiliza para modificar la actual sesión por alguna de las siguientes razones:

Habilitar o deshabilitar la facilidad SQL trace.


Habilitar o deshabilitar la resolución del nombre global.
Cambiar los valores de los parámetros NLS.
Especificar el tamaño de la memoria cache utilizada por los cursores.
Cerrar un enlace a base de datos.
Cambiar el nivel de transacción.
Para insertar, modificar o borrar de tablas con índices que se encuentran deshabilitados.

Para poder ejecutar este comando es necesario tener el privilegio ALTER SESSION. La sintaxis
es la siguiente:

ALTER SESSION { opciones } ;

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1

ALTER SESSION
SET SQL_TRACE = TRUE;

Ejemplo 2

ALTER SESSION

Sql_manual.doc 116
MANUAL DE SQL

SET NLS_LANGUAGE = French ;

Ejemplo 3

ALTER SESSION
SET NLS_DATE_FORMAT = ‘YYYY MM DD HH24:MI:SS’ ;

Ejemplo 4

ALTER SESSION
SET NLS_NUMERIC_CHARACTERS = ‘,.’ ;

Ejemplo 5

ALTER SESSION
SET NLS_ISO_CURRENCY = America ;

Ejemplo 6

ALTER SESSION ADVISE COMMIT ;


ALTER SESSION ADVISE ROLLBACK ;

Ejemplo 7

ALTER SESSION DISABLE COMMIT IN PROCEDURE ;

4.4.2 SET ROLE

Se utiliza para habilitar o deshabilitar roles de la sesión actual. La sintaxis es la siguiente:

SET ROLE {role [IDENTIFIED BY password] | ALL [EXCEPT [role]] | NONE };

Cuando estableces una conexión a la base de datos, Oracle establece cual es el dominio de
privilegios por defecto que te corresponde. Con este comando se puede cambiar el dominio durante la
sesión.

Se puede utilizar el comando SET ROLE para habilitar o deshabilitar alguno de los siguientes
roles:

Roles que te han sido directamente otorgados.


Roles que te han sido otorgados a través de otros roles.

Ejemplo

SET ROLE gardener IDENTIFIED BY marigolds;

Sql_manual.doc 117
MANUAL DE SQL

4.5 Comando de control del sistema

Este comando controla las propiedades de la instancia de Oracle. Este comando no actualiza
implícitamente las transacciones. PL/SQL no soporta este comando.

4.5.1 ALTER SYSTEM

Sirve para modificar dinámicamente tu instancia de Oracle por alguna de las siguientes razones:
Depurar explícitamente un punto de inserción (checkpoint).
Para verificar el acceso a los ficheros de datos.
Para terminar una sesión.
Para habilitar o deshabilitar el limite de los recursos.
Para borrar todos los datos del área compartida del área global del sistema.
Para habilitar o deshabilitar la resolución global del nombre.

Para poder ejecutar este comando es necesario tener el privilegio ALTER SYSTEM. La sintaxis
es la siguiente:

ALTER SYSTEM [ opciones ] ;

Para saber más acerca de las opciones consultar un manual.

Ejemplo 1
ALTER SYSTEM
ENABLE RESTRICTED SESSION;

Ejemplo 2ALTER SYSTEM


FLUSH SHARED_POOL;

Ejemplo 3

ALTER SYSTEM CHECKPOINT;

Ejemplo 4
ALTER SYSTEM
SET RESOURCE_LIMIT = TRUE ;

Ejemplo 5
ALTER SYSTEM
SET MTS_DISPATCHERS = ‘TCP, 5’
MTS_DISPATCHERS = ‘DECnet, 10’ ;

Ejemplo 6
ALTER SYSTEM
SET LICENCE_MAX_SESSIONS = 64
LICENCE_SESSIONS_WARNING = 54 ;

Ejemplo 7
ALTER SYSTEM ENABLE DISTRIBUTED RECOVERY ;

Sql_manual.doc 118
MANUAL DE SQL

Ejemplo 8
ALTER SYSTEM
KILL SESSION ’13, 8’ ;

Sql_manual.doc 119

Potrebbero piacerti anche