Академический Документы
Профессиональный Документы
Культура Документы
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
Sql_manual.doc 2
MANUAL DE SQL
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.
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
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.
'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.
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.
Sql_manual.doc 6
MANUAL DE SQL
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.
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.
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:
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.
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.
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.
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.
Es sinónimo del tipo de datos VARCHAR2, pero es recomendable utilizar este último.
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)
Los siguientes ejemplos muestran como Oracle almacena datos usando diferentes escalas y
precisiones.
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:
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.
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.
Las columnas LONG no pueden aparecer en ciertas partes de una orden SQL:
Sql_manual.doc 10
MANUAL DE SQL
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.
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
TO_CHAR
--------
2450450
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.
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 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.
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.
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.3 Tipos de datos DB2 y SQL/DS convertidos a tipos de datos Oracle
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.
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:
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
SELECT ename
FROM emp
WHERE hiredate = '12-MAR-1993';
También se puede especificar el tipo de conversión de datos que se desea realizar utilizando las
funciones de conversión de SQL.
Sql_manual.doc 14
MANUAL DE SQL
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.
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.
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.
Sql_manual.doc 15
MANUAL DE SQL
2.7 Pseudocolumnas
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:
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
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.
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
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:
Ejemplo 3
Sql_manual.doc 17
MANUAL DE SQL
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:
Usualmente, un ROWID identifica a un único registro de la base de datos, aunque se pueden dar
algunos casos en que esto no ocurra.
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:
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
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.
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.
Ejemplo
Sql_manual.doc 19
MANUAL DE SQL
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.
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.
Sql_manual.doc 20
MANUAL DE SQL
Sql_manual.doc 21
MANUAL DE SQL
Sql_manual.doc 22
MANUAL DE SQL
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.
Snapshots.
Snapshot log.
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.
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.
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.
Sintaxis
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:
Esta sección muestra como referenciar los objetos en el contexto de una orden SQL. En esta
sección se va a ver:
donde:
Sql_manual.doc 24
MANUAL DE SQL
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:
Sql_manual.doc 25
MANUAL DE SQL
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:
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 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:
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
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.
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.
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:
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.1 Operadores
Un operador manipula los datos individualmente y devuelve un resultado. Los operadores están
representados por caracteres especiales o por teclas.
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:
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.
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
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.
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.
Table created.
Concatenation
------------------------
Sql_manual.doc 29
MANUAL DE SQL
Sql_manual.doc 30
MANUAL DE SQL
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);
SELECT 'TRUE'
FROM emp
WHERE deptno NOT IN (5,15,null);
y como todas las operaciones que comparen un valor nulo, el resultado es un nulo, la expresión entera
resulta un nulo.
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
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:
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
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;
Sql_manual.doc 33
MANUAL DE SQL
3.1.8.3 Operador OR
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
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;
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.
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.1 ABS
Propósito Retorna el valor absoluto de n.
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.
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.
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.
Arc_Tangent
----------
.291456794
3.2.1.5 ATAN2
Arc_Tangent2
------------
.982793723
3.2.1.6 CEIL
Ceiling
----------
16
3.2.1.7 COS
Sql_manual.doc 38
MANUAL DE SQL
3.2.1.8 COSH
Hyperbolic cosine of 0
----------------------
1
3.2.1.9 EXP
3.2.1.10 FLOOR
Floor
----------
15
3.2.1.11 LN
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.
Sql_manual.doc 39
MANUAL DE SQL
3.2.1.13 MOD
Sintaxis MOD(m,n)
Propósito Retorna el resto de m dividido por n.
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:
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.
Raised
----------
9
3.2.1.15 ROUND
Sintaxis ROUND(n[,m])
Round
----------
Sql_manual.doc 40
MANUAL DE SQL
15.2
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
Sine of 30 degrees
------------------
.5
3.2.1.18 SINH
Hyperbolic sine of 1
--------------------
1.17520119
3.2.1.19 SQRT
Square root
-----------
5.09901951
Sql_manual.doc 41
MANUAL DE SQL
3.2.1.20 TAN
3.2.1.21 TANH
Hyperbolic tangent of .5
------------------------
.462117157
3.2.1.22 TRUNC
Truncate
----------
15.7
Truncate
----------
10
CHR
Sql_manual.doc 42
MANUAL DE SQL
C
-
A
CONCAT
Propósito Retorna el primer carácter concatenado con el segundo. Esta función es equivalente al
operador de concatenación.
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.
Capitals
---------
The Soap
LOWER
Sql_manual.doc 43
MANUAL DE SQL
FROM DUAL;
Lowercase
--------------------
mr. scott mcmillan
LTRIM
Propósito Cambia los caracteres que se encuentran a la izquierda de char, por el carácter que
viene especificado en set.
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.
Changes
--------------
BLACK and BLUE
RPAD
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.
RPAD example
-----------------
MORRISONabab
RTRIM
Sql_manual.doc 44
MANUAL DE SQL
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.
RTRIM e.g
-------------
BROWNINGyxX
SOUNDEX
Sintaxis SOUNDEX(char)
Propósito Retorna un string de caracteres que contiene la representación fonética de char.
Subs
----
CDEF
Subs
----
CDEF
SUBSTRB
Sql_manual.doc 45
MANUAL DE SQL
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)
Sql_manual.doc 46
MANUAL DE SQL
FROM DUAL;
Upper
-----
LARGE
ASCII
Sintaxis ASCII(char)
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.
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.
Length in bytes
---------------
14
Sql_manual.doc 47
MANUAL DE SQL
NLSSORT
Propósito Retorna el string de bytes usados para ordenar char. El valor de ‘nlsparams’ puede
tener la siguiente forma:
'NLS_SORT = sort'
ENAME
----------
SCOTT
SMITH
TURNER
WARD
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.
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.
Sql_manual.doc 48
MANUAL DE SQL
LAST_DAY(SYSDATE) "Last",
LAST_DAY(SYSDATE) - SYSDATE "Days Left"
FROM DUAL;
Five months
-----------
28-FEB-1982
3.2.3.3 MONTHS_BETWEEN
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.
Months
----------
1.03225806
3.2.3.4 NEW_TIME
3.2.3.5 NEXT_DAY
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.
NEXT DAY
---------
17-MAR-92
3.2.3.6 ROUND
Sintaxis ROUND(d[,fmt])
New Year
---------
01-JAN-93
3.2.3.7 SYSDATE
Sintaxis SYSDATE
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.
New Year
Sql_manual.doc 50
MANUAL DE SQL
---------
01-JAN-92
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.1 CHARTOROWID
Sintaxis CHARTOROWID(char)
ENAME
----------
LEWIS
3.2.4.2 CONVERT
Sql_manual.doc 51
MANUAL DE SQL
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.
3.2.4.4 RAWTOHEX
Sintaxis RAWTOHEX(raw)
Propósito Convierte raw a un valor de tipo carácter que contiene su hexadecimal correspondiente.
Graphics
--------
7D
ROWIDTOCHAR
Sintaxis ROWIDTOCHAR(rowid)
Sql_manual.doc 52
MANUAL DE SQL
ROWID
------------------
AAAAZ6AABAAABr1AAB
'NLS_DATE_LANGUAGE = language'
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.
Amount
--------------
$10,000.00-
Amount
-------------------
AusDollars10.000,00-
Sql_manual.doc 53
MANUAL DE SQL
3.2.4.7 TO_DATE
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.
3.2.4.8 TO_NUMBER
Propósito Convierte char, que es de tipo CHAR o VARCHAR2, a un valor de tipo NUMBER.
Amount
----------
-100
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.
Sql_manual.doc 54
MANUAL DE SQL
DUMP('ABC',1016)
------------------------------------------
Typ=96 Len=3 CharacterSet=WE8DEC: 61,62,63
OCTAL
----------------------------
Type=1 Len=5: 117,124
ASCII
----------------------------
Type=1 Len=5: 79,84
Propósito Retorna un localizador de LOB vacío que puede ser utilizado para inicializar una
variable LOB.
3.2.5.3 BFILENAME
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.
3.2.5.4 GREATEST
Sql_manual.doc 55
MANUAL DE SQL
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.
Great
-----
HARRY
3.2.5.5 LEAST
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.
LEAST
------
HAROLD
3.2.5.6 NVL
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 .
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
3.2.5.8 USER
Sintaxis USER
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'
Language
-----------------------------------
AMERICAN_AMERICA.WE8DEC
3.2.5.10 VSIZE
Sintaxis VSIZE(expr)
ENAME BYTES
---------- ----------
CLARK 5
Sql_manual.doc 57
MANUAL DE SQL
KING 4
MILLER 6
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)
Average
----------
2077.21429
3.2.6.2 COUNT
Sintaxis COUNT({* | [DISTINCT|ALL] expr})
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.
Total
----------
18
Sql_manual.doc 58
MANUAL DE SQL
Jobs
----------
5
3.2.6.3 MAX
Maximum
----------
5000
3.2.6.4 MIN
Earliest
---------
17-DEC-80
3.2.6.5 STDDEV
Sintaxis STDDEV([DISTINCT|ALL] x)
Deviation
----------
1182.50322
3.2.6.6 SUM
Sintaxis SUM([DISTINCT|ALL] n)
Sql_manual.doc 59
MANUAL DE SQL
Total
----------
29081
3.2.6.7 VARIANCE
Sintaxis VARIANCE([DISTINCT|ALL]x)
Variance
----------
1389313.87
Sql_manual.doc 60
MANUAL DE SQL
4 Comandos
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.
Ejemplo 1
Ejemplo 2
Sql_manual.doc 61
MANUAL DE SQL
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:
La sintaxis es la siguiente:
Ejemplo 1
Ejemplo 2
Ejemplo 3
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:
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
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:
Ejemplo 1
Ejemplo 2
Ejemplo 3
Ejemplo 4
Sql_manual.doc 63
MANUAL DE SQL
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:
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
Ejemplo
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
Ejemplo 2
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:
Ejemplo 1
Ejemplo 2
Para poder ejecutar este comando es necesario tener el privilegio ALTER ANY SEQUENCE. La
sintaxis es la siguiente:
Ejemplo
ALTER SEQUENCE eseq MAXVALUE 1500;
Se utiliza para modificar la definición de una tabla por alguna de las siguientes razones:
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:
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.
Sql_manual.doc 66
MANUAL DE SQL
Ejemplo 1
Ejemplo 2
Ejemplo 3
Ejemplo 1
Ejemplo 2
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
Sql_manual.doc 67
MANUAL DE SQL
Este comando se utiliza para modificar un espacio de tablas ya existente por alguna de las
siguientes razones:
Para poder ejecutar este comando se tiene que tener el privilegio ALTER TABLESPACE. La
sintaxis es la siguiente:
Ejemplo 1
Ejemplo 2
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
Ejemplo
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:
Ejemplo 1
Ejemplo 2
Sql_manual.doc 69
MANUAL DE SQL
Para poder ejecutar este comando es necesario tener el privilegio ALTER USER. La sintaxis es
la siguiente:
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:
Ejemplo
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 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:
Ejemplo 1
Ejemplo 2
Ejemplo 3
Ejemplo 4
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:
Ejemplo
COMMENT ON shipping.notes
IS ‘Special packing or shipping instructions’ ;
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:
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.
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
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.
Ejemplo
Sql_manual.doc 72
MANUAL DE SQL
Ejemplo
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:
Una tabla solo puede tener una primary key. Una primary key no puede ser de tipo LOB o REF.
Ejemplo
Sql_manual.doc 73
MANUAL DE SQL
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
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:
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.
Antes de definir una constraint de integridad referencial en la tabla hija, debe de estar definida la
constraint primary key en la tabla padre.
Ejemplo
Sql_manual.doc 74
MANUAL DE SQL
Ejemplo
Ejemplo
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:
Ejemplo 1
Sql_manual.doc 75
MANUAL DE SQL
Ejemplo
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.
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:
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.
Ejemplo
Sql_manual.doc 76
MANUAL DE SQL
Después de crear este índice se pueden introducir valores en las tablas dept y emp.
Para poder ejecutar este comando se tiene que tener habilitado el role OSDBA. La sintaxis es la
siguiente:
Ejemplo
Sql_manual.doc 77
MANUAL DE SQL
Se utiliza para crear una base de datos con las siguientes opciones:
Para ejecutar este comando se tiene que tener habilitado el role OSDBA. La sintaxis es la
siguiente:
Ejemplo
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:
Ejemplo
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:
Para poder crear un índice en otro esquema es necesario tener el privilegio CREATE ANY
INDEX. La sintaxis es la siguiente:
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
Ejemplo
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
Sql_manual.doc 80
MANUAL DE SQL
Ejemplo
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:
Ejemplo
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;
Sql_manual.doc 81
MANUAL DE SQL
END emp_mgmt;
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:
Ejemplo
Sql_manual.doc 82
MANUAL DE SQL
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:
CONNECT.
RESOURCE.
DBA.
EXP_FULL_DATABASE.
IMP_FULL_DATABASE.
DELETE_CATALOG_ROLE.
EXECUTE_CATALOG_ROLE.
SELECT_CATALOG_ROLE.
Ejemplo
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:
Ejemplo
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:
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
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:
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
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:
Sql_manual.doc 84
MANUAL DE SQL
Ejemplo
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:
Ejemplo
Sql_manual.doc 85
MANUAL DE SQL
Ejemplo
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
Ejemplo
Sql_manual.doc 86
MANUAL DE SQL
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;
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:
Oracle ejecuta automáticamente los disparadores. Se usan los disparadores por alguna de las
siguientes razones:
Habilitado.
Deshabilitado.
Sql_manual.doc 87
MANUAL DE SQL
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:
Las instrucciones que provocan que se dispare un trigger son las siguientes: DELETE, INSERT,
UPDATE y ON.
Oracle dispara el trigger cuando sucede la instrucción con la cual está relacionada.
Cuantas veces dispara Oracle el trigger.
Ejemplo
Sql_manual.doc 88
MANUAL DE SQL
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:
Además hay una serie de opciones, para conocer más acerca de ellas consultar un manual.
Ejemplo
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:
Sql_manual.doc 89
MANUAL DE SQL
Ejemplo
Se utiliza para crear un usuario de la base de datos. Se pueden asignar las siguientes
propiedades opcionales a un usuario:
Ejemplo
Sql_manual.doc 90
MANUAL DE SQL
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:
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:
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
COLUMN_NAME UPD
--------------- ----
ENAME YES
DEPTNO NO
EMPNO YES
LOC NO
Ejemplo 2
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:
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
Ejemplo 2
Sql_manual.doc 92
MANUAL DE SQL
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:
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
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:
Cuando se borra un cluster también se borra el índice del cluster y se recupera todo es espacio
que ocupaba el cluster.
Ejemplo
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:
Ejemplo
Sql_manual.doc 93
MANUAL DE SQL
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:
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
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:
Ejemplo
DROP INDEX monolith;
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:
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
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:
Ejemplo
Sql_manual.doc 94
MANUAL DE SQL
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:
Ejemplo
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:
Ejemplo
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:
Ejemplo
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:
Ejemplo
Sql_manual.doc 95
MANUAL DE SQL
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:
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:
Ejemplo
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:
Ejemplo
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:
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
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:
Ejemplo
DROP USER bradley CASCADE;
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:
Ejemplo
DROP VIEW view_data;
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
EXECUTE DBMS_IOT.BUILT_EXCEPTIONS_TABLE
(‘SCOTT’, ‘ORDERS’, ‘ORDER_EXCEPTIONS’);
Ejemplo 2
Sql_manual.doc 97
MANUAL DE SQL
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:
Ejemplo 1
Ejemplo 2
La siguiente tabla muestra los privilegios que se pueden asignar a cada tipo de objeto.
Sql_manual.doc 98
MANUAL DE SQL
Ejemplo 1
Ejemplo 2
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:
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.
Ejemplo
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:
El comando REVOKE solo puede revocar los privilegios o roles que han sido asignados por
medio del comando GRANT.
Ejemplo
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:
Sql_manual.doc 99
MANUAL DE SQL
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
Ejemplo 2
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:
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
Sql_manual.doc 100
MANUAL DE SQL
FROM emp
WHERE deptno =
(SELECT deptno FROM emp WHERE ename = ‘TAYLOR’);
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);
Ejemplo
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:
Ejemplo 1
Ejemplo 2
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.
Sql_manual.doc 102
MANUAL DE SQL
4.2.3 INSERT
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:
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:
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
Ejemplo 2
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:
Para conocer más acerca de cada una de las posibles opciones consultar un manual.
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;
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:
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.
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:
Los registros que cumplen la condición son los registros hijo del registro padre. Esta cláusula no
puede contener subconsultas.
Ejemplo
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
Ejemplo 2
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
Ejemplo
SELECT deptno, MIN (sal), MAX (sal)
FROM emp
WHERE job = ‘CLERK’
GROUP BY deptno;
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:
Hay que especificar las cláusulas GROUP BY y HAVING después de las cláusulas WHERE y
CONNECT BY.
Ejemplo
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
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.
Ejemplo 1
Ejemplo 2
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.
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
Ejemplo 2
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.
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
Sql_manual.doc 109
MANUAL DE SQL
Ejemplo 2
SELF JOINS
Un self join es un join de una tabla consigo misma. Esta tabla aparece dos veces en la cláusula
FROM.
Ejemplo
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.
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
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.
CUSTNO CUSTNAME
-------- -----------
1 Angelic Co.
2 Belieable Co.
3 Cabels R Us.
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
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.
Sql_manual.doc 113
MANUAL DE SQL
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:
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.
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’);
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:
Ejemplo
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:
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.
Oracle recomienda que todas las transacciones se terminen con la orden COMMIT o
ROLLBACK.
Ejemplo
4.3.3 SAVEPOINT
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;
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.
Se utiliza para modificar la actual sesión por alguna de las siguientes razones:
Para poder ejecutar este comando es necesario tener el privilegio ALTER SESSION. La sintaxis
es la siguiente:
Ejemplo 1
ALTER SESSION
SET SQL_TRACE = TRUE;
Ejemplo 2
ALTER SESSION
Sql_manual.doc 116
MANUAL DE SQL
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
Ejemplo 7
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:
Ejemplo
Sql_manual.doc 117
MANUAL DE SQL
Este comando controla las propiedades de la instancia de Oracle. Este comando no actualiza
implícitamente las transacciones. PL/SQL no soporta este comando.
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:
Ejemplo 1
ALTER SYSTEM
ENABLE RESTRICTED SESSION;
Ejemplo 3
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