Resumen OCA Primer Examen

Oracle Certified Associate
( OCA )
Examen 1
Introducción a SQL
Alfredo González Naranjo

Control de documentación
Versión Fecha Autor Comentario

1.0 24/02/2002 AGN Creación inicial
© Alfredo González Naranjo Página 2 de 66

Índice
0. INTRODUCCIÓN.................................................................................................................................5
1. LA SENTENCIA SELECT DE ORACLE..........................................................................................6
FUNDAMENTOS DE LA SENTENCIA SELECT.....................................................................................................6
USANDO PSEUDOCOLUMNAS...........................................................................................................................9
EXPRESIONES ARITMÉTICAS...........................................................................................................................10
TRATANDO VALORES NULL.......................................................................................................................11
FUNCIÓN NVL..........................................................................................................................................11
DEFINIR ALIAS DE COLUMNA.......................................................................................................................12
USO DEL OPERADOR DE CONCATENACIÓN........................................................................................................13
JOIN.......................................................................................................................................................13
2. FUNCIONES DE FILA.......................................................................................................................15
FUNCIONES DE FILA:....................................................................................................................................15
FECHAS EN ORACLE ..................................................................................................................................16
FUNCIONES DE CONVERSIÓN.........................................................................................................................19
FUNCIÓN DECODE..................................................................................................................................23
3. USANDO OPERADORES DE CONJUNTOS..................................................................................24
4. CREACIÓN DE SUBCONSULTAS..................................................................................................27
OPERADOR EXISTS / NOT EXISTS........................................................................................................30
UPDATE SINCRONIZADO...........................................................................................................................30
DELETE SINCRONIZADO............................................................................................................................31
5. CREACIÓN DE TABLAS..................................................................................................................32
OBJETOS DE UNA BD ORACLE.....................................................................................................................32
¿ QUÉ ES UN ESQUEMA ?.............................................................................................................................32
LA SENTENCIA CREATE TABLE.............................................................................................................33
TIPOS DE DATOS UTILIZABLES EN COLUMNAS...................................................................................................33
CONSTRAINTS EN UN CREATE TABLE.....................................................................................................34
CONSTRAINT NOT NULL.........................................................................................................................35
CONSTRAINT CHECK...............................................................................................................................35
CONSTRAINT PRIMARY KEY..................................................................................................................36
CONSTRAINT UNIQUE..............................................................................................................................36
CONSTRAINT FOREIGN KEY..................................................................................................................37
CREAR TABLAS BASÁNDOSE EN CONSULTAS.....................................................................................................38
ALTERAR UNA TABLA..................................................................................................................................38
CAMBIAR EL NOMBRE DE UN OBJETO..............................................................................................................41
TRUNCANDO UNA TABLA..............................................................................................................................41
BORRANDO UNA TABLA...............................................................................................................................41
AÑADIENDO COMENTARIOS A UNA TABLA.......................................................................................................42
6. OTROS OBJETOS DE LA BD..........................................................................................................43

VISTAS.....................................................................................................................................................43
CREACIÓN DE UNA VISTA.............................................................................................................................43
REGLAS PARA EJECUTAR OPERACIONES DML EN UNA VISTA.............................................................................45
MODIFICANDO UNA VISTA............................................................................................................................45
BORRANDO UNA VISTA................................................................................................................................46
SECUENCIAS...............................................................................................................................................46
PSEUDOCOLUMNAS NEXTVAL Y CURRVAL...........................................................................................47
ÍNDICES.....................................................................................................................................................49
GUÍAS PARA CREAR ÍNDICES.........................................................................................................................49
ELIMINANDO UN ÍNDICE...............................................................................................................................49
SINÓNIMOS................................................................................................................................................50
BORRANDO SINÓNIMOS................................................................................................................................50
7. CONTROLANDO TRANSACCIONES............................................................................................51
¿ QUÉ ES UNA TRANSACCIÓN ?.....................................................................................................................51
TIPOS DE TRANSACCIONES............................................................................................................................51
NOTAS SOBRE EL COMMIT Y ROLLBACK.............................................................................................51
SENTENCIAS DE CONTROL EXPLÍCITO DE TRANSACCIONES ...............................................................................52
CONSISTENCIA EN LECTURA.........................................................................................................................52
BLOQUEOS.................................................................................................................................................53
MODOS DE BLOQUEO...................................................................................................................................53
BLOQUEOS EXPLÍCITOS.................................................................................................................................53
8. CONTROL DE ACCESO DE USUARIOS A LA BD......................................................................55
CREANDO USUARIOS....................................................................................................................................55
MODIFICANDO LA PASSWORD DE USUARIOS.....................................................................................................55
PRIVILEGIOS DEL SISTEMA ( SYSTEM PRIVILEGES )..........................................................................................56
CONCEDIENDO PRIVILEGIOS DEL SISTEMA........................................................................................................56
PRIVILEGIOS DE OBJETOS ( OBJECTS PRIVILEGES )..........................................................................................56
CONCEDIENDO PRIVILEGIOS DE OBJETO...........................................................................................................57
¿ QUÉ ES UN ROL ?....................................................................................................................................58
ELIMINANDO PERMISOS ...............................................................................................................................58
9. DICCIONARIO DE DATOS..............................................................................................................59
ANEXO A: SQL* PLUS..........................................................................................................................61
ANEXO B: FICHEROS DE CONFIGURACIÓN................................................................................66

0. Introducción
El presente documento supone una útil herramienta de trabajo para la preparación del primer examen (
consta de un total de cinco), de la Certificación Oficial de Desarrollador Oracle ( OCP ).
El texto cubre la mayor parte de la materia ( la referida a SQL de Oracle, que supone un 85% del
contenido del primer examen ) incluida en dicho primer examen.
La exposición se ha ido realizando primando criterios de practicidad sobre retórica, sin perder por ello
un ápice de rigurosidad, y de este modo incrementando el carácter útil que siempre ha guiado el
desarrollo del documento.
Todos los comandos incluidos en el mismo no presentan una sintaxis completa, sino las opciones más
utilizadas en cada uno de los mismos. Para conocer todas y cada una de las opciones de cada
comando es necesario consultar el Manual de Referencia editado por el propietario del producto
( Oracle Corporation).

1. La sentencia SELECT de ORACLE
Fundamentos de la sentencia SELECT
SELECT [ DISTINCT | ALL ] { *, columna1 [ alias1 ], ….,expr1,….. }

FROM < tabla > | < vista >
[ WHERE < condicion/es >]
[ GROUP BY expr1 [, expr2] …. ]
[ HAVING condicion1 ]
[ ORDER BY { columna1, ..,expr1,…,alias1 } [ ASC| DESC ] ] ;
ALL: Es el valor por defecto. Devuelve todas las filas recuperadas, incluidas las repetidas ( esta
cláusula está en desuso).
HAVING : Se usa para restringir qué grupos de filas obtenidas por el GROUP BY son devueltas por la
consulta.
DISTINCT : Permite obtener una sola copia de el/los valor/es duplicado/s de columna/s.
Ejemplo:
SQL> SELECT DISTINCT JOB FROM emp;
JOB
---------
ANALYST
CLERK
MANAGER
SQL> SELECT DISTINCT JOB,MGR FROM emp;  No son necesarios los paréntesis
JOB MGR
--------- -----
ANALYST 7566  Se puede repetir el JOB, pero no la combinación JOB+MGR
ANALYST
CLERK 7698
CLERK 7782
CLERK 7788
CLERK 7902
MANAGER 7839
GROUP BY: Sirve para agrupar filas. La ordenación de los grupos es, por defecto, ascendente.
ORDER BY: Sirve para ordenar las filas recuperadas por la SELECT. La ordenación es, por defecto,
ascendente.

Nota1 : Las sentencias SQL no son sensibles a mayúsculas ( es indiferente escribirlas en mayúsculas
ó minúsculas ).
Nota2: Cuando en una sentencia SELECT se utiliza un GROUP BY y un ORDER BY a la vez,

las columnas que se incluyan en el ORDER BY también deben estar en el GROUP BY.
La cláusula WHERE admite dos tipos de operadores de comparación:
o Lógicos: >, < ,= ,<> ,!= ,..
o SQL: IS NULL, IS NOT NULL, (<exp1>,<exp2>,<exp3>,..) IN (val1,val2,val3,..), LIKE,

BETWEEN…..AND….., NOT IN , NOT LIKE, AND , OR , NOT,
Nota3: Si los valores incluidos en el conjunto IN son fechas, éstas son convertidas implícitamente de
cadenas de caracteres ( CHAR, VARCHAR2 ) a tipo DATE.
Ejemplo:
SQL> SELECT * FROM EMP

WHERE hiredate IN ('12/02/99','21/08/98');  Se realiza conversión implícita
Nota4: Si los valores incluidos en el conjunto IN son literales carácter que representan números
( todos sus caracteres son dígitos numéricos ) y el campo con el que se está comparado es numérico,
se realizarán una conversión implícita de CHAR / VARCHAR2 a NUMBER.
Ejemplo:
SQL> SELECT * FROM emp

2 WHERE mgr IN ('7566','7788');
 mgr es de tipo NUMBER

‘7566’ y ‘7788’ son convertidos implícitamente de tipo CHAR a NUMBER
Nota5: Las sentencias de tipo ‘campo1 IN (x1,x2,...,xN )’ se transforman internamente en:

Campo1= x1 OR campo1 = x2.....OR campo1 = xN.
Nota6: Las sentencias de tipo ‘campo1 NOT IN (x1,x2,...,xN )’ se transforman internamente en:
Campo1<> x1 AND campo1 <> x2.....AND campo1 <> xN.

ORDER BY: El orden de las filas devueltas por una consulta es indefinido.
- La cláusula ORDER BY debe ser la última de la sentencia SELECT.
- Se pueden incluir expresiones ó alias en un ORDER BY.
- Se puede especificar la posición de la expresión, columna ó alias por la que se quiere ordenar.
- En el ORDER BY pueden aparecer columnas que no se seleccionen en la SELECT pero que
pertenezcan a la tabla implicada.
- Los valores NULL son visualizados últimos cuando la ordenación es ASC y primeros cuando la
ordenación es DESC.
Ejemplo:
SQL> SELECT * FROM emp ORDER BY SAL+COMM DESC;  Se ordena por una expresión
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

----- ---------- --------- ----- ----------- --------- --------- ------
7369 SMITH CLERK 7902 17/12/80 800,00 20
7782 CLARK MANAGER 7839 09/06/81 2450,00 10
7654 MARTIN SALESMAN 7698 28/09/81 1250,00 1400,00 30
7499 ALLEN SALESMAN 7698 20/02/81 1600,00 300,00 30
7521 WARD SALESMAN 7698 22/02/81 1250,00 500,00 30
 Los primeros registros que aparecen son los que poseen COMM = NULL, puesto que
para ellos la expresión SAL+COMM evalúa a NULL y como la ordenación es DESCENDENTE,
los nulos se muestran primero.
SQL> SELECT empno,ename,SQRT(sal+comm*2.5) FROM emp ORDER BY 3;
EMPNO ENAME SQRT(SAL+COMM*2.5)

----- ---------- ------------------
7844 TURNER 38,7298334620742
7654 MARTIN 68,9202437604511
7369 SMITH
7566 JONES  Los nulos aparecen al final por ser orden ASC
Nota7: Se puede colocar un ORDER BY en una sentencia SELECT que incluya la cláusula DISTINCT.
Ejemplo:
SQL> SELECT DISTINCT JOB,MGR FROM EMP

2 ORDER BY 1;  Ordena por JOB ASCendentemente
JOB MGR
--------- -----
ANALYST 7566
ANALYST
CLERK 7698
CLERK 7902
MANAGER 7839
Los caracteres comodín para la cláusula LIKE son:

a) ‘_’ ( representa un carácter )
b) ‘%’ ( representa una cadena de caracteres de cualquier longitud)
La cláusula LIKE tiene una sintaxis del tipo:
LIKE ‘patron’ [ ESCAPE ‘caracter_escape’ ]
Ejemplo:
SQL> SELECT * FROM tabla1

2 WHERE campo1 LIKE ‘%N\%P\%O%’ ESCAPE ‘\’;
Para que el patrón de búsqueda pueda contener los caracteres ‘_’ y ‘%’ se usa la cláusula ESCAPE
Si además, se quiere buscar el caracteres Escape dentro del patrón, se debe escribir dos veces.
Ejemplo:
Si el carácter ESCAPE es ‘/’ , para buscar la cadena ‘Cliente/Servidor’ se puede especificar un patrón
del tipo ‘%Cliente//Servidor%’
Justificaciones por defecto:
Tipo de dato Justificación por defecto

NUMBER Derecha
CHAR Izquierda
VARCHAR2 Izquierda
DATE Izquierda
Operadores lógicos negados:
Operador Descripción
NOT columna1 = No es igual a
NOT columna1 > No es mayor que
Usando Pseudocolumnas
Una pseudocolumna se comporta como una columna de la tabla, pero no está almacenada en ninguna
tabla. Sobre una pseudocolumna sólo se puede realizar operación de SELECT.
ROWID: Por cada fila recuperada, la pseudocolumna ROWID devuelve la dirección física de la fila. Los
índices contienen ROWIDs .

ROWNUM: Por cada fila recuperada, la pseudocolumna ROWNUM devuelve un número que indica el
orden en el cual Oracle ha seleccionado la fila de la tabla ( no es el orden físico de las filas en la tabla).
La primera fila seleccionada tiene asignado un 1, la segunda un 2, y así sucesivamente.
Ejemplos:
SQL> SELECT ename,job,ROWNUM,ROWID FROM emp;
ENAME JOB ROWNUM ROWID

---------- --------- ---------- ------------------
SMITH CLERK 1 AAAAcUAACAAAAEbAAA
ALLEN SALESMAN 2 AAAAcUAACAAAAEbAAB
SQL> SELECT * FROM emp WHERE ROWNUM<2;  devuelve sólo la primera fila

----- ---------- --------- ----- ----------- --------- --------- ------
7369 SMITH CLERK 7902 17/12/80 800,00 20
SQL> SELECT * FROM emp WHERE ROWNUM>1;

----- ---------- --------- ----- ----------- --------- --------- ------
 No devuelve ninguna fila, puesto que la primera fila devuelta tiene un ROWNUM=1 y
no cumple la condición, la segunda, vuelve a ser la posible primera, con lo que
ROWNUM=1 y tampoco cumple la condición y así sucesivamente.
Expresiones aritméticas
Una expresión aritmética puede contener:
a) Nombres de columnas
b) Constantes numéricas
c) Operadores aritméticos ( + , - , * , / )
Ejemplo:
SELECT ename,sal,sal*0.1
FROM emp
Si una expresión aritmética contiene más de un operador, ésta se evaluará según la prioridad de éstos.
• *, / ( más prioridad )
• +, - ( menos prioridad )
Si todos los operadores de la expresión tienen la misma prioridad, se evaluarán de izquierda a

derecha.

Para cambiar el orden de evaluación se pueden utilizar paréntesis.
Tratando valores NULL

Un NULL es un valor, sin un tipo asignado, que es desconocido e inaplicable.
Cualquier columna de una tabla, independientemente del tipo de dato base, puede contener un valor
NULL, a menos que ésta sea definida como NOT NULL ó como PRIMARY KEY ( Una columna
definida como UNIQUE sí que puede contener valores nulos ).
Ejemplo:
SQL> CREATE TABLE ALFREDO1

(CAMPO1 NUMBER(2) PRIMARY KEY,
CAMPO2 VARCHAR2(10) UNIQUE);
SQL> DESC ALFREDO1

Name Type Nullable Default Comments
------ ------------ -------- ------- --------
CAMPO1 NUMBER(2)
CAMPO2 VARCHAR2(10) Y
Cualquier operación que se haga con un valor NULL devuelve un NULL. Así, por ejemplo, si se intenta
realizar una división por cero se obtiene un error ( excepción ZERO_DIVIDE ), pero si se intenta dividir
por NULL, el resultado es NULL ( no se produce error ).
Ejemplo:
SQL> SELECT * FROM EMP WHERE EMPNO;

----- ---------- --------- ----- ----------- --------- --------- ------
7369 SMITH CLERK 7902 17/12/80 800,00 20
7499 ALLEN SALESMAN 7698 20/02/81 1600,00 300,00 30
SQL> SELECT ENAME AS NOMBRE,SAL*12+COMM AS SUELDO FROM EMP;
NOMBRE SUELDO
---------- ----------
SMITH  El cálculo devuelve NULL
ALLEN 19500
Igualmente, cualquier comparación con valores NULL siempre es FALSE.
Función NVL
Convierte un valor nulo (NULL) en otro valor.

NVL ( expr1,expr2)
Si expr1 es NULL, entonces se devuelve expr2. En caso contrario, se devuelve expr1.

expr2 debe ser del mismo tipo de dato que expr1.
Ejemplos:
Tipo de Dato Función Valor devuelto si expr1 es NULL

NUMBER NVL(columna_Number,10) 10 ( NUMBER )
DATE NVL(columna_Date,’01-JAN-95’) ’01-JAN-95’ ( DATE )
VARCHAR2 NVL(columna_Varchar2,’Hola’) ‘Hola’ (VARCHAR2 )
Aunque generalmente los tipos de datos del “valor si NULL” (expr2) y expr1 deben coincidir, ORACLE
ejecuta muchas conversiones implícitas de tipos sobre expr2.
Ejemplo:
SQL> SELECT ENAME,COMM,NVL(SQRT(COMM),'0')AS RAIZ FROM EMP;
ENAME COMM RAIZ

---------- --------- ----------
SMITH 0
ALLEN 300,00 17,3205080756888
 Dado que la columna COMM está definida de tipo NUMBER, Oracle realiza una
conversión implícita de CHAR a NUMBER ( de ‘0’ (CHAR) a 0 (NUMBER)).
Definir Alias de Columna

Se puede cambiar la cabecera de las columnas visualizadas por una consulta utilizando alias.
Los alias se especifican después de cada columna ó expresión de la cláusula SELECT usando un
espacio como separador ( la utilización de la palabra reservada AS no es necesaria ).
Por defecto, los alias se muestran, cuando se ejecuta la consulta, en mayúsculas.
Si el alias contiene espacios, caracteres especiales (‘#’,’$’,...) ó minúsculas, el alias debe encerrarse
entre comillas dobles (“ ”).
Los alias de columna pueden ser utilizados, después del FROM, únicamente en una cláusula ORDER
BY (ni en GROUP BY, ni en condiciones del WHERE, ni en HAVING, etc...). Sin embargo, los alias de
tabla se pueden utilizar en cualquier cláusula posterior y anterior al FROM.
Ejemplo:
SQL> SELECT ename AS nombre FROM EMP;
NOMBRE Aparece en mayúsculas, por defecto

----------
SMITH

ALLEN
.....
SQL> SELECT ename nombre FROM EMP;  La cláusula AS no es necesaria
NOMBRE
----------
SMITH
ALLEN
SQL> SELECT ename "Nombre de Pila$" FROM EMP;
Nombre de Pila$  Con espacios ó caracteres especiales se utilizan “ “

--------------
SMITH
ALLEN
Uso del operador de concatenación

El operador de concatenación (‘||’) permite enlazar columnas a otras columnas, a expresiones
aritméticas ó valores constantes para crear un expresión tipo carácter
Las constantes de tipo fecha y de tipo carácter deben estar encerradas entre comillas simples (Eje:
‘Hola’,’12-FEB-02’,..). Sin embargo, las constantes numéricas no necesitan ir entre comillas (Eje: 3.25,
4,..).
Oracle realiza conversiones implícitas de tipo ( para pasar todas las columnas implicadas a tipo
carácter).
Ejemplo:
SQL> SELECT ename||' '||sal||' '|| (1+2)||' '|| hiredate AS "Chorizo" FROM emp;
Chorizo
--------------------------------------------------------------
SMITH 800 3 17/12/80  La expres.(1+2) se evalúa y después se concatena
ALLEN 1600 3 20/02/81  Se convierte de tipo Date y Number a Char
.....
JOIN
Se utilizan para recuperar datos de más de una tabla. El enlace entre tablas se realiza en base a
valores comunes de columnas de las distintas tablas.
Hay varios tipos de JOIN:
- EQUIJOIN: Es aquella que contiene en la condición de join un operador de igualdad.

- NO-EQUIJOIN: Se utiliza para enlazar dos tablas cuando ninguna columna de la primera tabla se
relaciona directamente con alguna columna de la segunda tabla . Un non-equijoin se define usando
un operador distinto al de igualdad. Dado que no existen columnas comunes, no es necesario
utilizar alias de tablas para cualificar las columnas ( aunque su uso mejora el rendimiento ).
- OUTER JOIN: Se usa el operador (+). Sirve para mostrar filas que no se recuperarían con una join
normal ( equijoin ), debido a que en alguna de las columnas que se igualan no existe valor
asociado ( NULL ).
- SELF-JOIN: Cuando se hace join de una tabla consigo misma.
Cuando se escriban sentencias SELECT que enlazan tablas, es conveniente preceder cada columna
de la tabla con el nombre de la misma ó con el alias definido correspondiente, para mejorar el
rendimiento de la BD.
Nota1: Para enlazar “n” tablas se necesita un mínimo de “n-1” condiciones de join ( para claves
compuestas de más de una columna, el número de condiciones se incrementa considerablemente).
OUTER JOIN (+): Visualiza filas que no cumplen la condición de join debido a que no existe
correspondencia en una tabla ( existen valores NULL ) para algunos valores de la otra tabla.
El operador se coloca en la columna de la tabla dónde no hay valor para enlazar. El operador (+)
puede ser colocado en cualquier lado de la igualdad, pero no en los dos.
En una condición que incluya un OUTER-JOIN no se puede usar el operador IN ,ni ser enlazada a otra
condición con el operador OR. Sí se puede utilizar el operador AND.
Ejemplo:
SQL> SELECT E.ENAME,D.DEPTNO

2 FROM EMP E,DEPT D
3 WHERE E.DEPTNO(+)=D.DEPTNO
4 OR E.DEPTNO=5
5 ;
ORA-01719: operador de unión externa (+) no permitido en operando OR ni IN
Nota2: Si dos tablas son enlazadas por múltiples condiciones de JOIN, se debe usar en todas el
operador (+).
Nota3: Una condición no puede comparar una columna marcada con el operador (+) con una
subconsulta.
Ejemplo:
SQL> SELECT E.ENAME,D.DEPTNO

FROM EMP E,DEPT D
WHERE E.DEPTNO(+) = (SELECT D.DEPTNO FROM dept d);
ORA-01799: una columna no puede estar unida externamente a una subconsulta

2. Funciones de Fila
Las funciones SQL se dividen en dos grupos:
a) Funciones de fila: Devuelven un resultado por cada fila

b) Funciones de grupo: Devuelve un resultado por cada grupo
Funciones de fila:
Los diferentes tipos de funciones de fila se agrupan en los siguientes conjuntos:
a) Funciones de CARÁCTER.
b) Funciones de NÚMERO.
c) Funciones de FECHA.
d) Funciones de CONVERSIÓN.
e) Funciones GENERALES.
Funciones de CARÁCTER
LOWER(colum1|expr1): Convierte una cadena de caracteres a minúsculas.

UPPER(colum1|expr1): Convierte una cadena de caracteres a mayúsculas.
INITCAP(colum1|expr1): Convierte la primera letra de cada palabra en mayúsculas y el resto en
minúsculas.
CONCAT(colum1|expr1, colum2|expr2): Concatena dos cadenas. Es equivalente a ‘||’.
SUBSTR(colum1|expr1,m[,n]): Devuelve la subcadena de longitud ‘n’ extraída comenzando por la
posición ‘m’. Si ‘m’ es negativo, la cuenta comienza desde el final de la cadena.La extracción siempre
es de izquierda a derecha.
LENGTH(colum1|expr1): Devuelve el número de caracteres de la cadena.
INSTR(colum1|expr1,subcadena): Devuelve la posición de la primera ocurrencia de una subcadena en
una cadena.
LPAD(colum1|expr1,n,’subcadena’): Rellena, por la izquierda de la cadena, con el valor de
‘subcadena’, hasta que se tenga en total ‘n’ posiciones ( caracteres).
RPAD(colum1|expr1,n,’subcadena’): Igual que LPAD pero rellenando por la derecha
Funciones de NÚMERO
ROUND(colum1|expr1,n): Redonde a ‘n’ decimales. Si ‘n’ es omitido, quita los decimales, redondeando
previamente. Si ‘n’ es negativo, redondea la parte entera (si ‘n’=-1 redondea a la decena más próxima,
si ‘n’ =-2 redondea a la centena más próxima ). Si ‘n’ es negativo y su valor es mayor ó igual que el
número de dígitos de la parte entera, el resultado será cero.
TRUNC(colum1|expr1,n): Trunca a ‘n’ decimales. Si ‘n’ es omitido, quita los decimales. Si ‘n’ es
negativo, trunca la parte entera.

MOD(m,n): Devuelve m en módulo n ( resto de dividir ‘m’ entre ‘n’).
Fechas en Oracle
Oracle almacena las fechas en un formato numérico interno, representando el siglo,el año, el mes,el
día, la hora, los minutos y los segundos. El formato de visualización y entrada de datos, por defecto, es
‘DD-MON-YY’ ( este formato por defecto puede ser cambiado, tanto a nivel de la Base de Datos, cómo
a nivel de Sesión ).
SYSDATE es una función que devuelve la fecha y la hora actual. Esta función se puede usar como
cualquier otra columna. No es necesario usar la tabla DUAL para recuperar la fecha y hora actual.
Ejemplo:
SQL> SELECT empno,SYSDATE FROM emp;  No es necesario usar la tabla DUAL
EMPNO SYSDATE
----- -----------
7369 14/05/02 19:37:52
7499 14/05/02 19:37:52
SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
-----------
14/05/02 19:38:14
Nota1: La tabla DUAL pertenece al usuario SYS y puede ser usada por todos los usuarios. Contiene
una sola columna, DUMMY, y una sola fila con el valor X. La tabla DUAL es útil cuando quieres
obtener un valor único ( una expresión que no implica ninguna columna de una tabla, una fecha, etc...).
Ejemplo:
SQL> DESC DUAL;

----- ----------- -------- ------- --------
DUMMY VARCHAR2(1) Y
SQL> SELECT * FROM DUAL;
DUMMY
-----
X

Puesto que las fechas se almacenan en la BD como números, se pueden realizar cálculos aritméticos
con las fechas.
Operación Tipo devuelto Descripción

DATE + NUMBER DATE Suma un número de días a la fecha
DATE – NUMBER DATE Resta un número de días de la fecha
DATE – DATE NUMBER Calcula la diferencia en días de una fecha con
respecto a otra. Para que el resultado sea
positivo la primera fecha debe ser posterior a la
segunda
DATE + NUMBER / 24 DATE Añade un número de horas a la fecha. Para
sumar horas a una fecha hay que sumar
fracciones.
Ejemplo:
SQL> SELECT ename,TRUNC((SYSDATE-hiredate)/365) "Años en la empresa" FROM emp;
ENAME Años en la empresa

---------- ------------------
SMITH 21
ALLEN 25
WARD 20
Funciones de Fecha:
Función Descripción
MONTHS_BETWEEN(fecha1,fecha2) Calcula el número de meses ( con parte
entera y decimal ) entre dos fechas. El
resultado puede ser negativo ó positivo. Si
fecha1 es posterior a fecha2 el resultado
será positivo.
ADD_MONTHS(fecha, n) Añade ‘n’ ( debe ser entero ) meses a la
fecha. ‘n’ puede ser positivo ó negativo.
NEXT_DAY(fecha,’día_de_la_semana’|posic) Devuelve la fecha del próximo día de la
semana especificado como segundo
parámetro ( el nombre del día depende del
idioma configurado en la BD), siguiente a la
fecha pasada como primer parámetro.
También se puede indicar, en lugar del día
de la semana, un número representado el
día de la semana (1 Lunes, 2
Martes,...).
LAST_DAY(fecha) Devuelve la fecha del último día del mes
correspondiente al mes de la fecha que se
pasa como parámetro
ROUND(fecha[,’formato’]) Devuelve la fecha redondeada a la unidad
especificada en el formato. Si se omite el
formato, la fecha se redondea al día más
próximo

TRUNC(fecha[,’formato’]) Devuelve la fecha truncada a la unidad
especificada en el formato. Si se omite el
formato, la fecha se trunca al día más
próximo
Ejemplos:
SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
-----------
15/05/02 12:02:41
SQL> SELECT NEXT_DAY(SYSDATE,1) FROM DUAL;
NEXT_DAY(SYSDATE,1)
-------------------
20/05/02 12:02:55  Será la fecha del próximo Lunes ( 1er día de la semana )
SQL> SELECT LAST_DAY(SYSDATE) FROM DUAL;
LAST_DAY(SYSDATE)
-----------------
31/05/02 12:03:08
SQL> SELECT ROUND(SYSDATE,'MONTH') FROM DUAL;
ROUND(SYSDATE,'MONTH')
----------------------
01/05/02
SQL> SELECT ROUND(SYSDATE,'YEAR') FROM DUAL;
ROUND(SYSDATE,'YEAR')
---------------------
01/01/02
SQL> SELECT TRUNC(SYSDATE,'MONTH') FROM DUAL;
TRUNC(SYSDATE,'MONTH')
----------------------
01/05/02
SQL> SELECT TRUNC(SYSDATE,'YEAR') FROM DUAL;
TRUNC(SYSDATE,'YEAR')
---------------------
01/01/02
Como vemos, las funciones TRUNC y ROUND puede ser utilizadas para números y fechas. Cuando se
utilizan con fechas, éstas se truncan ó redondean según el formato pasado como parámetro.

Funciones de Conversión
El servidor Oracle puede realizar conversiones implícitas de tipos de datos. Las conversiones
explícitas son realizadas por los usuarios haciendo uso de las funciones de conversión de tipos de
datos.
Conversiones implícitas:
Desde A
VARCHAR2 ó CHAR (*) NUMBER
VARCHAR2 ó CHAR (*) DATE
NUMBER VARCHAR2
DATE VARCHAR2
(*) La conversión VARCHAR2 ó CHAR a NUMBER funciona sólo si la cadena de caracteres

representa un número.
(*) La conversión VARCHAR2 ó CHAR a DATE funciona sólo si la cadena representa una fecha con el
formato por defecto (‘DD-MON-YY’).
Ejemplos:
SQL> SELECT '1'+2 SUMA FROM DUAL;  Conversión de CHAR a NUMBER
SUMA
----------
3
SQL> SELECT 'HOLA'||(2+3) SALU FROM DUAL;  Conversión de NUMBER a CHAR
SALU
-------------
HOLA5
SQL> SELECT 'DÍA: '||'12-OCT-74' FROM DUAL; Conversión de DATE a CHAR
'DÍA:'||'12-OCT-74'
-------------------
DÍA: 12-OCT-74
Conversiones explícitas:
Función Objetivo
TO_CHAR(numero|fecha [, ‘formato’]) Convierte un número ó una fecha a una
cadena de caracteres VARCHAR2 usando
el formato pasado como parámetro
TO_NUMBER(cadena) Convierte una cadena de caracteres que
contiene dígitos numéricos a un NUMBER
TO_DATE(cadena [, ‘formato’] Convierte una cadena de caracteres

representando una fecha a un valor tipo
DATE, de acuerdo al formato especificado.
Si no se indica formato, se utiliza el ‘DD-
MON-YY).
TO_CHAR:
A ) Uso de TO_CHAR con Fechas:
Por defecto, todas las fechas se visualizan utilizando el formato por defecto especificado en la
configuración de la BD (normalmente, ‘DD-MON-YY). El usuario puede cambiar la forma en que se
visualizan las fechas, haciendo uso de la función TO_CHAR y especificando un formato concreto.
Nota1:
- El formato debe ser especificado entre comillas simples y es sensible a mayúsculas.
- Para eliminar espacios en blanco ó ceros a la izquierda se puede utilizar el elemento de formato
‘fm’
Ejemplo:
SQL> SELECT TO_CHAR(SYSDATE,'DD-MON-YYYY') FROM DUAL;
TO_CHAR(SYSDATE,'DD-MON-YYYY')
------------------------------
15-MAY-2002
SQL> SELECT TO_CHAR(SYSDATE,'dd-mon-yyyy') FROM DUAL;
TO_CHAR(SYSDATE,'DD-MON-YYYY')
------------------------------
15-may-2002  El formato de conversión es sensible a Mayúsculas
Elementos de formato para fechas:
Elemento Descripción
SCC ó CC Siglo, ‘S’ prefija fechas BC ( antes de cristo) con ’-‘
YYYY ó SYYYY Año, ‘S’ prefija fechas BC ( antes de cristo) con ’-‘
YYY,ó YY ó Y Los 3,2 y 1 últimos dígitos del año
Y,YYY Año con una coma en la posición indicada
IYYY,IYY,IY,I Los 4,3,2 y 1 últimos dígitos del año en estándar ISO
SYEAR ó YEAR Año en letras. ‘S’ prefija fechas BC ( antes de cristo) con un ‘-‘
BC ó AD Añade a la fecha el indicador de si es Después de Cristo ó Antes de Cristo
Q Cuarto de año ( número de trimestre )
MM Mes, con dos dígitos
MONTH Mes en letras

MON 3 letras representativas del mes
RM Mes en números romanos
WW ó W Semana del año ó del mes
DDD ó DD ó D Día del año, ó mes, ó semana
DAY Día de la semana en letras
DY 3 letras representativas del día de la semana
J Día Juliano
Elementos de formato para horas:
AM ó PM Antes del mediodía ó después
A.M. ó P.M. Antes del mediodía ó después, con puntos
HH ó HH12 ó HH24 Hora del día
MI Minutos
SS Segundos
SSSS Segundos transcurridos desde las 00:00
/.,: Signos de puntuación incluidos en la fecha
“cadena” La cadena es reproducida tal cual
TH Número ordinal ( ej: ‘DDTH’ para ‘4th’)
SP Número en letras (ej: ‘DDSP’ para ‘Cuatro’)
SPTH ó THSP Número ordinal en letras (ej:’DDSPTH’ para ‘Cuarto’)
B) Uso de TO_CHAR con Números:
La conversión de NUMBER a VARCHAR2 haciendo uso del TO_CHAR se suele utilizar cuando se
quiere concatenar un valor numérico en un formato determinado con una cadena de caracteres
Elementos de formato para números:
9 Posiciones numéricas (anchura del resultado). Si el número a visualizar posee
menos dígitos que el número de dígitos del formato (número de 9 consecutivos ) se
rellena con blancos
0 Visualiza ceros por la izquierda hasta completar la longitud del formato especificado
$ Antepone el signo de dólar al número
L Coloca en la posición dónde se incluya, el símbolo de la moneda local ( configurada
en la BD mediante el parámetro NSL_CURRENCY)
. Coloca un punto decimal en la posición indicada
, Coloca una coma en la posición indicada
MI Coloca un signo menos a la derecha del número (si éste es negativo)
PR Coloca los números negativos entre ‘<’ y ‘>’
EEEE Especifica un número en notación científica
V Devuelve un valor multiplicado por 10n dónde ’n’ es el número de 9s después de la V
B Devuelve blancos para la parte entera de un número de punto fijo cuando la parte
entera es 0 ( independientemente de los 0’s que existan en el formato especificado )

Nota1:
Oracle visualiza una cadena de caracteres compuesta por el carácter ‘#’ cuando el valor representar
es mayor que el número de dígitos del formado especificado.
TO_NUMBER:
TO_NUMBER(cadena): Convierte una cadena de caracteres en un número
Ejemplo:
SQL> select TO_NUMBER('34434') from DUAL;
TO_NUMBER('34434')
------------------
34434  Se ha convertido de tipo CHAR ó VARCHAR2 a tipo NUMBER
TO_DATE:
TO_DATE(cadena,[,’formato’]): Convierte una cadena de caracteres en una fecha. Los elementos de

formato serán los mismos que los presentados en la función TO_CHAR.
Ejemplo:
SQL> select TO_DATE('20020522','YYYYMMDD') FROM DUAL;
TO_DATE('20020522','YYYYMMDD')
------------------------------
22/05/02  Se ha convertido de tipo CHAR ó VARCHAR2 a tipo DATE
Nota1:
El elemento de formato ‘RR’ para fechas es similar al ‘YY’ pero permite especificar siglos diferentes.
Se puede usar ‘RR’ en lugar de ‘YY’ cuando el siglo del valor que se quiere convertir difiera del siglo
actual del sistema. ‘YY’ siempre asume el siglo actual.
El comportamiento de ‘RR’ se rige por la siguiente tabla:
Si los dos dígitos del año especificado están entre

0-49 50-99
Últimos dos dígitos 0-49 La fecha devuelta está en el SIGLO La fecha devuelta
del año actual en el ACTUAL está en el SIGLO
sistema ANTERIOR al actual
50-99 La fecha devuelta está en el SIGLO La fecha devuelta
POSTERIOR al actual está en el SIGLO
ACTUAL

Función DECODE
DECODE (columna | expresion, patron1, resultado1,

[, patron2,resultado2,......]
[,valor_default ] )
La función DECODE es similar a una estructura IF-THEN-ELSE.
Si se omite el valor por defecto (valor_default) se devolverá un NULL cuando la expresión no encaje
con ninguno de los patrones especificados.
La evaluación es secuencial, por lo que si se encuentra un patrón que cumpla la condición, se

devuelve su resultado asociado y no se sigue comparando.
Oracle convierte cada patrón, y la expresión que se están buscando, al tipo de dato del primer patrón.
Además, convierte el resultado devuelto al tipo de dato del primer resultado especificado (resultado 1).
Nota1:
En un DECODE, Oracle considera a los nulos iguales. Es decir, si columna ó expresión es NULL ,
Oracle devuelve el primer resultado asociado a un patrón que sea también NULL ( es decir, en este
caso NULL = NULL!!!! ).

3. Usando Operadores de Conjuntos
Los operadores de conjunto combinan los resultados de dos ó más consultas en una sola.
En las operaciones de conjuntos, el número de columnas y tipos seleccionados en las dos consultas
deben ser iguales ( los nombres de las columnas no tienen por qué coincidir).
Operador Resultado
INTERSECT Combina los resultados de dos consultas y devuelve aquellas filas de la
primera que existen al menos una vez en la segunda
UNION Devuelve todas las filas seleccionadas por ambas consultas. Las filas
duplicadas sólo aparecen una vez (sólo se chequea la duplicidad de las
columnas seleccionadas).
El operador IN tiene mayor precedencia que el UNION.
El resultado se ordena, por defecto, en orden ASCendentemente.
UNION ALL Devuelve todas las filas seleccionadas por ambas consultas, incluyendo
todas las filas duplicadas.
El resultado, por defecto, no se ordena.
El operador DISTINCT no puede ser utilizado
MINUS Combina los resultados de dos consultas y devuelve aquellas filas de la
primera que no existen en la segunda
Todos los operadores de conjunto tienen igual precedencia. Por tanto, si existen varios operadores en
la misma sentencia, se evalúan de izquierda a derecha, siempre y cuando no aparezca paréntesis que
cambien el orden de manera explícita.
Ejemplos:
SQL> select ename,empno,job from emp

2 union
3 select dname,deptno,’0’ from dept;
ENAME EMPNO JOB

-------------- ---------- ---------
ACCOUNTING 10 0
ADAMS 7876 CLERK
..
SQL> select ename,empno from emp

2 union all
3 select dname,deptno from dept;
ENAME EMPNO
-------------- ----------
SMITH 7369
ALLEN 7499
WARD 7521
JONES 7566

…

2 intersect
ENAME EMPNO
-------------- ----------

2 minus
ENAME EMPNO
-------------- ----------
ADAMS 7876
ALFREDO 8000
ALLEN 7499
BLAKE 7698
.....
Reglas de operadores de conjuntos:
- Si ambas consultas seleccionan valores de tipo CHAR, el resultado devuelto es de tipo CHAR.
- Si una consulta selecciona un tipo CHAR y la otra un tipo VARCHAR2, el resultado devuelto es de
tipo VARCHAR2.
- La cláusula ORDER BY puede aparecer sólo al final de la sentencia y aceptará un nombre de la
columna, un alias ó notación posicional. Si un nombre de columna ó alias es usado en un ORDER
BY deben ser de la primera SELECT.
- Los operadores de conjunto pueden ser usados en subconsultas.
- Los encabezados de columnas del resultado de la operación de conjunto son los nombres de las
columnas de la primera SELECT.
Nota1: Como la lista de expresiones que aparecen en las SELECT deben coincidir en número y tipo,
se pueden usar columnas ficticias y funciones de conversión de tipos para cumplir dicha regla.
Ejemplo:
SQL> SELECT deptno,TO_CHAR(NULL) AS location, hiredate

2 FROM EMP
3 UNION
4 SELECT deptno,loc,TO_DATE(NULL)
5 FROM DEPT;
DEPTNO LOCATION HIREDATE

---------- ------------- -----------
10 NEW YORK
10 09/06/81
10 17/11/81
10 23/01/82

20 DALLAS
20 17/12/80
20 02/04/81
20 03/12/81
20 19/04/87
20 23/05/87

4. Creación de subconsultas
Una subconsulta es una sentencia SELECT que está embebida en una cláusula de otra sentencia.
La consulta interna (ó subconsulta ) devuelve valores que son usados por la sentencia externa.
SELECT expr1,expr2,....
FROM tabla1
WHERE expr3 operador ( SELECT expr11,expr12…
FROM tabla2);
Los operadores de enlace entre las consultas son del tipo: ‘>’ ,’=’ ,IN ,...
Los operadores de enlace se pueden dividir en dos grupos:

a) Operadores de una fila ( esperan un único valor)
b) Operadores de múltiples filas ( esperan múltiples valores ).
Operadores de Comparación:
Operador Significado
= Igual a
> Mayor que
>= Mayor ó igual que
< Menor que
<= Menor ó igual que
<> Distinto de
IN (*) Compara un valor con cada valor devuelto por la subconsulta
ANY (*)/ Compara un valor con cada valor devuelto por la subconsulta y evalúa a
SOME (*) TRUE si la condición se cumple para alguno de los valores devueltos.
ALL (*) Compara un valor con cada valor devuelto por la subconsulta y evalúa a
TRUE si la condición se cumple para todos los valores devueltos
(*) Operadores de múltiples filas.
Una subconsulta no pueden contener una cláusula ORDER BY.
Nota1:
Si una subconsulta devuelve un valor NULL y se está utilizando un operador NOT IN , provocará que la
consulta principal no devuelva ninguna fila.
Ejemplo:

2 WHERE comm IN (SELECT distinct comm FROM emp);

 Existen registros en la tabla cuyo valor para el campo comm es NULL, pero al
utilizarse el IN ( que implícitamente son OR, por lo que si una condición es FALSE (
comm = NULL => FALSE ) no provoca que toda la condición sea FALSE )

----- ---------- --------- ----- ----------- --------- --------- ------
7844 TURNER SALESMAN 7698 08/09/81 1500,00 0,00 30
7499 ALLEN SALESMAN 7698 20/02/81 1600,00 300,00 30
7521 WARD SALESMAN 7698 22/02/81 1250,00 500,00 30
7654 MARTIN SALESMAN 7698 28/09/81 1250,00 1400,00 30

2 WHERE comm NOT IN (SELECT distinct comm FROM emp);

----- ---------- --------- ----- ----------- --------- --------- ------
SQL>
 Al utilizarse el NOT IN ( que implícitamente son comm <> valor1 AND comm <>
valor2 ... ,son AND, por lo que si una condición es FALSE ( comm <> NULL => FALSE )
provoca que toda la condición sea FALSE )
Ejemplos:
SQL> SELECT ename

2 FROM emp
3 WHERE sal > (SELECT sal  Subconsulta de una fila
4 FROM emp
5 WHERE empno=7566);
ENAME
----------
SCOTT
KING
FORD
Las subconsultas se ejecutan antes que la consulta principal.
Subconsultas en la cláusula FROM:
Se puede utilizar una subconsulta en la cláusula FROM de una SELECT ( se creará una especie de
almacenamiento temporal de datos )
Ejemplo:
SQL> SELECT a.ename,a.sal,a.deptno

2 FROM emp a, (SELECT deptno,AVG(sal) salario_medio
3 FROM emp
4 GROUP BY deptno) b
5 WHERE a.deptno = b.deptno
6 AND a.sal > b.salario_medio;

ENAME SAL DEPTNO
---------- --------- ------
KING 5000,00 10
FORD 3000,00 20
SCOTT 3000,00 20
JONES 2975,00 20
ALLEN 1600,00 30
BLAKE 2850,00 30
6 rows selected
Nota2: El operador IN se puede utilizar para comparar tuplas de valores.
SQL> SELECT ename,deptno,sal,comm

2 FROM emp
3 WHERE (sal,NVL(comm,-1)) IN (SELECT sal,NVL(comm,-1)
5 FROM emp
6 WHERE deptno=30);
ENAME DEPTNO SAL COMM

---------- ------ --------- ---------
JAMES 30 950,00
WARD 30 1250,00 500,00
MARTIN 30 1250,00 1400,00
TURNER 30 1500,00 0,00
ALLEN 30 1600,00 300,00
BLAKE 30 2850,00
6 rows SELECTed
Subconsultas Sincronizadas:
Las subconsultas sincronizadas son aquellas que son evaluadas una vez por cada fila procesada de la
sentencia padre ( SELECT,UPDATE,DELETE). Oracle ejecuta una subconsulta sincronizada cuando
en la subconsulta se referencia a una columna de una tabla de la consulta padre.
Diferencia entre la ejecución de una subconsulta anidada y una subconsulta sincronizada:
Subconsulta anidada:
1.- Se ejecuta la consulta interna primero y devuelve un valor.

2.- Se ejecuta la consulta externa, usando el valor devuelto por la consulta interna.
Subconsulta sincronizada:
1.- Se selecciona una fila candidata de la consulta externa ( se realiza un fetch ).

2.- Se ejecuta la consulta interna usando el valor de la fila candidata.
3.- Se usa el resultado de la consulta interna para dar por válida ó no la fila candidata.
4.- Repetir el proceso hasta que no queden filas en la consulta externa.

Ejemplo:
SQL> SELECT deptno,ename,sal

2 FROM emp e
3 WHERE sal > (SELECT AVG(sal)
4 FROM emp
5 WHERE e.deptno=deptno)
6 ORDER BY deptno;
DEPTNO ENAME SAL

------ ---------- ---------
10 KING 5000,00
20 JONES 2975,00
20 SCOTT 3000,00
20 FORD 3000,00
30 ALLEN 1600,00
30 BLAKE 2850,00
 La subconsulta es evaluada para cada fila devuelta por la consulta externa

(SELECT principal)
Operador EXISTS / NOT EXISTS

Es un operador muy utilizado con subconsultas sincronizadas. Se comprueba si una determinada
condición se cumple en la subconsulta.
Ejemplo:
SQL> SELECT empno,ename,job,deptno

2 FROM emp externa
3 WHERE EXISTS ( SELECT empno
4 FROM emp interna
5 WHERE interna.mgr=externa.empno);
EMPNO ENAME JOB DEPTNO

----- ---------- --------- ------
7566 JONES MANAGER 20
7698 BLAKE MANAGER 30
7782 CLARK MANAGER 10
7788 SCOTT ANALYST 20
7839 KING PRESIDENT 10
7902 FORD ANALYST 20
6 rows Selected
UPDATE sincronizado

Actualiza filas de una tabla basándose en filas de otra tabla
Ejemplo:
SQL> UPDATE emp e

SET dname = (SELECT dname
FROM dept d
WHERE e.deptno = d.deptno)
DELETE sincronizado
Borra las filas de una tabla que también existe en otra tabla
Ejemplo:
SQL> DELETE FROM emp externa

WHERE ROWID > (SELECT MIN(ROWID)
FROM emp interna
WHERE externa.empno = interna.empno)

5. Creación de tablas
Objetos de una BD Oracle

Algunos de los objetos que se pueden crear en una BD Oracle son:
• Tablas
• Vistas
• Secuencias
• Índices
• Sinónimos
¿ Qué es un esquema ?
Un esquema es una colección de objetos. Los objetos de un esquema incluyen tablas, vistas,
sinónimos, secuencias, procedimientos almacenados, índices, clusters y DB links. El esquema es
propiedad de un usuario y posee el mismo nombre que el usuario.
Reglas para nombres de objetos de la BD Oracle:
1. Los nombres de las tablas, vistas,...etc, y de las columnas deben comenzar por una letra y
tener un tamaño máximo de 30 caracteres.
2. Los nombres deben contener caracteres del conjunto (A-Z, a-z, 0-9, ’_’, ’$’, ’#’).
3. Los nombres asignados a un objeto no deben ser idénticos a objetos ya existentes propiedad
del usuario.
4. Oracle permite introducir nombres tanto en minúsculas como en mayúsculas ( no los distingue,
no es sensible a mayúsculas ). Para distinguirlos, sería necesario introducir los nombres entre
comillas dobles. Oracle soporte nombres entre comillas dobles, permitiendo utilizar nombres
que son palabras reservadas, que son sensibles a mayúsculas ó que contienen espacios.
Ejemplo:
SQL> CREATE TABLE tabla3

2 ("Antoñito Bueno" NUMBER(3));  Se pueden utilizar espacios
TABLE CREATED

2 ("GROUP BY" VARCHAR2(10));  Se pueden utilizar palabras reservadas
TABLE CREATED
SQL> DESC tabla3;


-------------- --------- -------- ------- --------
Antoñito Bueno NUMBER(3) Y  El campo se crea idéntico a la definición
SQL> DESC tabla4;

-------- ------------ -------- ------- --------
GROUP BY VARCHAR2(10) Y
La sentencia CREATE TABLE
CREATE TABLE [esquema].tabla

( columna1 tipodato1 [ DEFAULT expresion1]
[constraint_column1],
...
[constraint_tabla]);
Para poder crear una tabla, el usuario tiene que tener el privilegio de sistema “CREATE TABLE” y
existir espacio libre en disco para poder crear el objeto.
La cláusula DEFAULT permite especificar un valor por defecto si éste se omite en una sentencia
INSERT. El valor por defecto puede ser un literal (numérico ó carácter), una expresión ó una función
SQL del tipo SYSDATE ó USER, pero el valor no puede ser el nombre de otra columna ó de una
pseudocolumna (NEXTVAL,CURRVAL,..).
La cláusula CONSTRAINT de la sentencia CREATE TABLE soporta opciones adicionales, tales como:
ON DELETE CASCADE, ENABLE, DISABLE, etc.
Tipos de datos utilizables en columnas

Tipo de dato Descripción
VARCHAR2(tamaño) Cadenas de caracteres de longitud variable con longitud
máxima igual a ‘tamaño’. Es necesario especificar un
tamaño. No rellena con blancos.
CHAR[(tamaño)] Cadenas de caracteres de longitud fija con longitud máxima
igual a ‘tamaño’. El tamaño por defecto es 1 (no es obligatorio
especificar un tamaño) . Rellena con blancos
NUMBER(p,s) Datos numéricos de longitud variable. ‘p’ ( precisión ) especifica
el número total de dígitos y ‘s’ ( escala ) el número de dígitos de
la parte decimal. Si un valor excede la precisión, Oracle
devuelve un error. Si un valor excede la escala, Oracle lo
redondea.
DATE Valores de fecha y hora
LONG Cadenas de caracteres de longitud variable de hasta 2 Gb
RAW(tamaño) Datos binarios de longitud máxima ‘tamaño’

LONG RAW Datos binarios de longitud variable de hasta 2 Gb
CLOB Cadenas de caracteres de hasta 4 Gb
BLOB Datos binarios de hasta 4 Gb
BFILE Datos binarios de hasta 4 Gb almacenados en un fichero
externo ( puntero a un fichero )
ROWID Representación hexadecimal ó en base 64 ( según la versión
de Oracle ) de la posición física de una fila en una tabla
Constraints en un CREATE TABLE

El servidor Oracle usa las constraints para asegurar la integridad de datos.
Los nombres de las constraints deben seguir las reglas especificadas anteriormente para nombrar
cualquier tipo de objeto en la BD Oracle.
Constraint Descripción Columna Tabla

NOT NULL Especifica que la columna no puede contener valores X
nulos
UNIQUE Especifica que una columna ó conjunto de columnas X X
deben tener valores únicos para todas las filas de la
tabla
PRIMARY KEY Identifica unívocamente cada fila de la tabla X X
FOREIGN KEY Establece y fuerza una relación entre dos tablas X X
CHECK Especifica una condición que debe cumplir los datos X X
de la tabla
Las constraints NOT NULL y UNIQUE son implícitamente creadas cuando se crea una constraint
PRIMARY KEY en una tabla.
Las CONSTRAINTs se pueden crear tanto a nivel de tabla como a nivel de columna.
Las constraints pueden ser añadidas a la tabla después de la creación de ésta y además, también
pueden ser temporalmente deshabilitadas.
Constraint a nivel de columna:
.......
Columna1 .....[CONSTRAINT nombre_constraint ] tipo_constraint,
.......
Las constraints a nivel de columna referencian una sola columna y son definidas dentro de la propia
definición de la columna.
Constraint a nivel de tabla:

........
ColumnaN
[CONSTRAINT nombre_constraint ] tipo_constraint ( columna1,columna2,…)
……
Las constraints a nivel de tabla referencian una ó mas columnas y son definidas después de la
definición de las columnas de la tabla. En este nivel se puede definir cualquier tipo de constraints salvo
NOT NULL que tiene que ser definida a nivel de columna.
Constraint NOT NULL

Esta constraint impide que valores nulos sean almacenados en la columna.
Ejemplo:
SQL>CREATE TABLE tabla7

2 (campo71 NUMBER(2) DEFAULT 0 CONSTRAINT campo71_no_nulo NOT NULL);
TABLE CREATED
Constraint CHECK
Esta constraint define una condición que cada fila de la tabla debe satisfacer. La condición puede usar
los mismos constructores que los utilizados en condiciones de consultas, con las siguientes
salvedades:
- No se pueden referenciar las pseudocolumnas: CURRVAL, NEXTVAL, ROWNUM ( al igual que la
cláusula DEFAULT para columnas).
- No se pueden invocar a las funciones SYSDATE y USER ( al contrario que la cláusula DEFAULT
para columnas ).
No está limitado el número de constraint de tipo CHECK asociadas a una columna.
La condición de la check constraint puede incluir cualquier columna de la tabla ( se tendría que definir
la constraint a nivel de tabla y no a nivel de columna ), pero no se puede referir a columnas de otras
tablas.
Ejemplo:

2 (campo81 number(2) CONSTRAINT chequeo_1 CHECK(campo81 > 20));
TABLE CREATED

Constraint PRIMARY KEY
Sólo se puede crear una PRIMARY KEY por tabla.
La constraint PRIMARY KEY es una columna ó conjunto de columnas que identifican unívocamente a
cada fila de la tabla.
Ninguna columna que forme parte de la PRIMARY KEY puede contener valores nulos (Todas las
columnas son NOT NULL y UNIQUE).
Un índice único (UNIQUE) es creado implícitamente cuando se crea una PRIMARY KEY sobre una
tabla.
Ejemplo:
SQL> CREATE TABLE TABLA10

2 (campo101 number(3),
3 campo102 number(5),
4 campo103 varchar2(10),
5 CONSTRAINT clave_prim PRIMARY KEY(campo101));  Constraint a nivel de tabla
TABLE CREATED
Constraint UNIQUE
Una constraint UNIQUE sirve para mantener la unicidad de una columna ó conjunto de columnas.
Las constraints UNIQUE permiten introducir valores NULL a menos que se definan en las columnas
correspondientes la constraint NOT NULL.
El servidor Oracle crea un índice único ( UNIQUE ) de manera implícita cuando se crea una constraint
de tipo UNIQUE.
Ejemplo:

2 (campo101 number(3) PRIMARY KEY,  La cláusula CONSTRAINT es opcional
4 CONSTRAINT clave_unica UNIQUE(campo102));
TABLE CREATED

Constraint FOREIGN KEY
La FOREIGN KEY ó constraint de integridad referencial, designa una columna ó conjunto de columnas
como clave ajena y establece una relación con una PRIMARY KEY ó UNIQUE KEY de la misma ó
diferente tabla.
Los valores de la FOREIGN KEY deben existir en la tabla relacionada ó ser nulos ( la relación se hace
a nivel de datos, no físicamente con punteros).
Las tablas referenciadas en este tipo de constraint deben existir en la misma BD. Si la tabla no
pertenece al usuario que está creando la constraint, se debe preceder el nombre de la tabla con el
nombre del propietario de la misma.
La constraint FOREING KEY puede ampliarse con una serie de cláusulas adicionales:
a) FOREIGN KEY: Se usa para definir la/s columna/s en la tabla hija en la definición de la constraint a
nivel de tabla.
b) REFERENCES: Identifica la tabla y columna/s en la tabla padre.
c) ON DELETE CASCADE: Indica que cuando un fila en la tabla padre sea borrada, las filas
dependientes en las tabla hijas también serán borradas. Sin esta opción, las filas en la tabla padre no
pueden ser borradas si existen filas en las tabla hija que las referencien.
Ejemplos:

2 (campo101 number(3),
4 campo103 varchar2(10),
5 CONSTRAINT clave_prim PRIMARY KEY(campo101));
TABLE CREATED

2 (CAMPO110 NUMBER(2) PRIMARY KEY,
3 (CAMPO111 NUMBER(2) CONSTRAINT clave_aj REFERENCES tabla10(campo101)
4 ON DELETE CASCADE );  Definición de clave ajena a nivel de columna
TABLE CREATED
SQL>CREATE TABLE TABLA12

2 (CAMPO121 NUMBER(2) PRIMARY KEY,
3 (CAMPO122 NUMBER(2),
4 CONSTRAINT clave_aj2 FOREIGN KEY (campo122) REFERENCES
5 tabla10(campo101) ON DELETE CASCADE);  Definición a nivel de tabla
TABLE CREATED

Crear tablas basándose en consultas
CREATE TABLE nombre_tabla
[(columna1,columna2,...,columnaN)]
AS
< subconsulta >
La definición de las columnas puede contener únicamente el nombre de la columna,su valor por
defecto y constraint de integridad .No puede contener el tipo de dato ni constraint de integridad
referencial( FOREIGN KEY ).
Sólo las constraint NOT NULL se heredan de la tabla involucrada en la subconsulta.
Ejemplo:
SQL> CREATE TABLE tabla_alfredo

2 as
3 SELECT empno,ename FROM emp WHERE deptno=20;
Alterar una tabla

Después de crear una tabla, puede ser necesario modificar alguna característica de la misma
ALTER TABLE nombre_tabla

ADD (columna1 tipodato1 [DEFAULT expres] [NOT NULL],
......);
Añade columnas a una tabla.
Las columnas se añaden al final de la tabla.
Se pueden añadir y modificar columnas de una tabla, pero no BORRARLAS.
Si la tabla a la que se va añadir una nueva columna contiene filas, la nueva columna contendrá valores
nulos para todas las filas de la tabla.
Una columna que va ser añadida a una tabla, no puede ser definida como NOT NULL, a menos que la
tabla esté vacía.
Ejemplo:
SQL> DESC TABLA1

------- ------------ -------- ------- --------
CAMPO11 NUMBER Y
CAMPO12 VARCHAR2(10) Y

SQL> ALTER TABLE TABLA1
2 ADD (CAMPO13 VARCHAR2(10) DEFAULT 'HOLA' CONSTRAINT C_1 NOT NULL);
TABLE altered

ADD ( [ CONSTRAINT nombre_constraint] tipo_constraint (columna));
Añade una constraint a una tabla existente.
Se pueden añadir, borrar, habilitar ó deshabilitar constraints, pero no modificar su estructura.
Ejemplo:

2 ADD (CONSTRAINT cons_1 FOREIGN KEY(campo11) REFERENCES TABLA10(campo110));
TABLE altered

MODIFY ( columna1 tipodato1 [DEFAULT expres1] [NOT NULL],
. columna2 tipodato2 [DEFAULT expres2] [NOT NULL]
.....);
Modifica columnas ya existentes
La modificación de una columna puede incluir cambios en el tipo de dato (la tabla debe estar vacía ó la
columna contener valores nulos), en el tamaño (si se decrementa, la tabla debe estar vacía ó la
columna contiene valores nulos ), en el valor por defecto (afecta a los nuevos valores insertados en la
tabla ) y en la constraint NOT NULL (la tabla debe estar vacía).
Nota1:
Se puede cambiar una columna de tipo CHAR a VARCHAR2 si la columna contiene valores nulos ó
está vacía, y además no cambias el tamaño de la columna.
Ejemplo:

2 MODIFY (campo12 VARCHAR2(50));
TABLE altered

DROP PRIMARY KEY | UNIQUE (columna) | CONSTRAINT nombre_constraint [CASCADE];
Ejemplo:

2 DROP PRIMARY KEY CASCADE;
TABLE altered
Borra constraints ya existentes en la tabla.
La opción CASCADE causa que cualquier constraint dependiente de la que se está borrando, sea
borrada también.

DISABLE CONSTRAINT nombre_constraint [CASCADE];
Se puede deshabilitar una constraint sin borrarla y crearla de nuevo, usando la cláusula DISABLE de
la sentencia ALTER TABLE.
La cláusula DISABLE se puede utilizar tanto en un ALTER TABLE como en un CREATE TABLE.
La cláusula CASCADE deshabilita constraints que dependan de la que estamos deshabilitando.
Ejemplo:
SQL> ALTER TABLE emp

2 DISABLE CONSTRAINT emp_empno_pk CASCADE;
TABLE altered

ENABLE CONSTRAINT nombre_constraint;
Se puede habilitar una constraint sin borrarla y crearla de nuevo usando la cláusula ENABLE de la
sentencia ALTER TABLE.
La cláusula ENABLE se puede utilizar tanto en un ALTER TABLE como en un CREATE TABLE.
Si se habilita una constraint, esa validación se aplica a todos los datos de la tabla ( todas las filas
deben cumplir la condición impuesta por la constraint ).
Si tu habilitas una constraint de tipo UNIQUE ó PRIMARY KEY, un índice único es creado
automáticamente.
Ejemplo:
SQL> ALTER TABLE emp

2 ENABLE CONSTRAINT emp_empno_pk;
TABLE altered

Cambiar el nombre de un objeto
RENAME nombre_viejo TO nombre_nuevo;
Permite renombrar una tabla, una vista, una secuencia ó un sinónimo.
Para poder renombrar un objeto, el usuario debe ser el propietario del objeto.
Ejemplo:
SQL> RENAME tabla11 TO tabla1001;
TABLE renamed
Truncando una tabla
TRUNCATE TABLE nombre_tabla;
Esta operación elimina todas las filas de la tabla y libera el espacio ocupado por la misma.
Para poder realizar un TRUNCATE el usuario debe ser el propietario de la tabla ó tener el privilegio del
sistema DELETE TABLE
Ejemplo:
SQL> TRUNCATE TABLE tabla1;
TABLE truncated
Borrando una tabla
DROP TABLE nombre_tabla [CASCADE CONSTRAINTS];
Esta operación elimina todas las filas de la tabla y los índices. Con la opción CASCADE
CONSTRAINTS también se eliminará cualquier constraint de integridad referencial que haga
referencia a alguna de las columnas de la tabla borrada.
Cuando se ejecuta esta sentencia, cualquier vista ó sinónimo que haga referencia a la tabla borrada
resultará inválido ( pero seguirá existiendo).
Sólo el propietario de la tabla ó un usuario con el privilegio del sistema DROP ANY TABLE puede
borrar una tabla.
Ejemplo:

SQL> DROP TABLE tabla1;
TABLE dropped
Añadiendo comentarios a una tabla
COMMENT ON TABLE nombre_tabla IS ‘texto’
Añade comentarios a una tabla ó vista
Ejemplo:
SQL> COMMENT ON TABLE tabla1 IS ‘Tabla 1 de prueba’;
Comment CREATED
COMMENT ON COLUMN nombre_tabla.nombre_columna IS ‘texto’
Añade comentarios a una columna de una tabla
Ejemplo:
SQL> COMMENT ON COLUMN tabla1.campo11 IS ‘Campo1 de la tabla’;
Comment dropped
Nota1: Para borrar un comentario de la base de datos basta con asignar una cadena vacía en el texto
posterior al IS ( ... IS ‘ ‘)

6. Otros objetos de la BD
Vistas
Una vista no es más que una sentencia SELECT almacenada en el Diccionario de Datos.
Las vista son utilizadas para imponer una seguridad en los datos, visualizando un porción SELECTiva
de información.
Una vista puede estar basada en un tabla ó conjunto de tablas, ó en otra vista.
Diferencia entre Vistas Simples y Vistas Complejas
Característica Vista Simple Vista Compleja

Número de tablas Una Una ó mas
Contiene funciones No Sí
Contiene grupos de datos No Sí
( DISTINCT ó funciones de
grupo )
Permite sentencias DML Sí No siempre
(INSERT,UPDAT
E,DELETE)
Creación de una vista
CREATE [ OR REPLACE ] [FORCE | NOFORCE] VIEW nombre_vista

[( alias1,…..,aliasN)]
AS subconsulta
[ WITH CHECK OPTION [ CONSTRAINT nombre_constraint]]
[ WITH READ ONLY ]
OR REPLACE: Vuelve a crear la vista, si esta ya existe

FORCE: Crea la vista independientemente de si existe ó no la tabla base.
NOFORCE: Crea la vista si la tabla base existe ( es el valor por defecto )
WITH CHECK OPTION: Especifica que sólo las filas accesibles a la vista pueden ser insertadas ó
actualizadas. Si se intenta ejecutar una operación DML sobre filas que la vista no ha seleccionado, se
muestra un error con el nombre de la constraint (si ésta ha sido especificada en la cláusula ).
WITH READ ONLY: Especifica que sólo se podrán realizar operaciones de lectura sobre la vista
(SELECT).
La subconsulta no puede contener un ORDER BY.

Si no se especifica un nombre de constraint para una vista creada con la cláusula WITH CHECK
OPTION, el sistema asignará un nombre por defecto del tipo “SYS_Cn”.
Se puede utilizar la cláusula OR REPLACE para cambiar la definición de la vista sin borrarla y tenerla
que crear de nuevo y sin tener que volver a conceder todos los privilegios sobre la vista.
Si en la subconsulta se incluyen alias de columna y no se especifican nombres de columna para la

vista, las columnas de ésta tomarán los nombres de los alias de la subconsulta.
Cuando la subconsulta retorna alguna función ó expresión, es obligatorio especificar los nombres de
las columnas de la vista ( alias de la vista ).
Ejemplo:
SQL> CREATE VIEW vista1

2 AS SELECT empno,ename,job
3 FROM emp
4 WHERE deptno=10;
View CREATED
Ejemplo:
SQL> SELECT * FROM vista1;
EMPNO ENAME JOB

----- ---------- ---------
7782 CLARK MANAGER
7839 KING PRESIDENT
7934 MILLER CLERK
SQL>
Ejemplo:
SQL> CREATE VIEW dept_sum_vu

2 AS SELECT d.dname,MIN(e.sal),MAX(e.sal),AVG(e.sal)
3 FROM emp e, dept d
4 WHERE e.deptno=d.deptno
5 GROUP BY d.dname
ORA-00998: hay que nombrar esta expresión con un alias de columna
SQL> CREATE VIEW dept_sum_vu

2 (nombre,salario_minimo,salario_maxino,salario_medio)
3 AS SELECT d.dname,MIN(e.sal),MAX(e.sal),AVG(e.sal)
4 FROM emp e, dept d
5 WHERE e.deptno=d.deptno
6 GROUP BY d.dname
View CREATED

SQL> SELECT * FROM dept_sum_vu;
NOMBRE SALARIO_MINIMO SALARIO_MAXINO SALARIO_MEDIO

-------------- -------------- -------------- -------------
ACCOUNTING 1300 5000 2916,66666666667
RESEARCH 800 3000 2175
SALES 950 2850 1566,66666666667
SQL>
Reglas para ejecutar operaciones DML en una vista

- Se pueden ejecutar operaciones DML en vistas simples.
DELETE:
No se pueden eliminar filas a través de una vista si contiene:

a) Funciones de grupo
b) Cláusula GROUP BY
c) Un DISTINCT
Tampoco se pueden eliminar filas a través de una vista si la definición de la vista no contiene todas las
columnas de la tabla base definidas como NOT NULL.
UPDATE:
No se pueden actualizar filas a través de una vista si cumple alguna de las condiciones anteriores ó si
contiene:
a) Expresiones
b) La pseudocolumna ROWNUM
INSERT:
No se pueden insertar filas a través de una vista si se cumple alguna de las condiciones anteriores ó
si:
a) La tabla contiene una columna NOT NULL, sin un valor por defecto, y dicha columna no es
seleccionada por la vista.
Modificando una vista

La opción OR REPLACE permite crear una vista incluso si ya existe una con el mismo nombre,
reemplazando la antigua versión de la vista por la nueva. Esto significa que la vista puede ser
modificada sin tenerla que borrar, crear de nuevo, y conceder de nuevo todos los privilegios que
existían sobre la vista.

Ejemplo:
SQL> CREATE OR REPLACE view VISTA1

2 (numero_empleado,nombre,trabajo)
3 AS SELECT empno,ename,job
4 FROM emp
5 WHERE deptno=10;
View CREATED
SQL>
El comando ALTER VIEW sirve para recompilar una definición de vista existente ( Este tipo de
sentencias se ejecutarán cuándo se realicen cambios en la definición de la tabla base sobre la que
está creada la vista ).
Borrando una vista
DROP VIEW nombre_vista
Sólo el propietario de la vista ó un usuario con el privilegio del sistema ‘DROP ANY TABLE’ puede
borrar una vista.
Ejemplo:
SQL> DROP VIEW view;
View dropped.
SQL>
Secuencias
CREATE SEQUENCE nombre_secuencia

[ INCREMENT BY n ]
[ START WITH n ]
[{ MAXVALUE n | NOMAXVALUE }]
[{ MINVALUE n | NOMINVALUE }]
[{ CYCLE | NOCYCLE }]
[{ CACHE n | NOCACHE }]
INCREMENT BY : Especifica el intervalo entre cada número generado ( por defecto es 1 )

START WITH: Especifica el primer número a generar ( por defecto es 1 )
MAXVALUE: Especifica el valor máximo que puede generar la secuencia

NOMAXVALUE: Especifica un valor máximo de 1027 para secuencias ascendentes y de –1 para
secuencias descendentes ( es el valor por defecto )
MINVALUE: Especifica el valor mínimo de la secuencia
NOMINVALUE: Especifica un valor mínimo de 1 para secuencias ascendentes y de 1026 para
secuencias descendentes ( es el valor por defecto )
CYCLE : Especifica que la secuencia comenzará por el principio ( valor mínimo ) cuando se quiera
generar el valor siguiente al máximo
NOCYCLE: Especifica que la secuencia producirá un error al intentar obtener el valor siguiente al
máximo ( NOCLYCLE es la opción por defecto )
CACHE: Especifica cuántos valores el servidor Oracle guardará en memoria ( el valor por defecto es
20).
NOCACHE: Obliga al servidor Oracle a no guardar ningún valor en memoria
Ejemplo:
SQL> CREATE SEQUENCE secuencia1

2 INCREMENT BY 2
3 START WITH 100
4 MAXVALUE 200
5 NOCYCLE
6 NOCACHE;
Sequence CREATED
SQL>
Una secuencia es un generador de números consecutivos.

Una secuencia es un objeto de BD creado por un usuario y que puede ser utilizado por múltiples
usuarios.
Pseudocolumnas NEXTVAL y CURRVAL

NEXTVAL: Cuando se hace referencia a “nombre_secuencia.NEXTVAL” se genera un nuevo valor, y
dicho valor generado es colocado en CURRVAL ( sirve para conocer por que valor va la secuencia ).
Se debe invocar a NEXTVAL antes de hacer uso de CURRVAL en cada sesión de usuario.
Ejemplo:
SQL> CREATE sequence secuencia3

2 start with 3;
Sequence CREATED
SQL> SELECT secuencia3.currval FROM DUAL;
SELECT secuencia3.currval FROM DUAL
ORA-08002: la secuencia SECUENCIA3.CURRVAL todavía no se ha definido en esta sesión

SQL> SELECT secuencia3.nextval FROM DUAL;
NEXTVAL
----------
3
SQL> SELECT secuencia3.currval FROM DUAL;
CURRVAL
----------
3
Si se realiza un rollback de una sentencia que contiene una secuencia, el número generado por la
secuencia se pierde y la próxima vez que se invoque a ésta generará el siguiente ( aparecerán
huecos ). Otra accción que puede causar la aparición de huecos es la caída del sistema. Si la
secuencia tenía valores en caché, entonces todos esos valores se perderán.
Reglas para usar NEXTVAL y CURRVAL:
- Se puede usar NEXTVAL y CURRVAL en:

o La lista de columnas visualizadas por una SELECT que no es parte de una subconsulta.
o La lista de columnas de una SELECT en una sentencia INSERT/SELECT.
o La cláusula VALUES de un INSERT.
o La cláusula SET de una sentencia UPDATE.
- No se puede usar NEXTVAL y CURRVAL en:

o La lista de columnas visualizadas por una SELECT que configura una vista.
o Una sentencia SELECT con un DISTINCT.
o Una sentencia SELECT con un GROUP BY,HAVING ó ORDER BY.
o Una subconsulta en una sentencia SELECT,DELETE ó UPDATE.
o Una cláusula DEFAULT en un CREATE TABLE ó ALTER TABLE.
Modificar una secuencia

ALTER SEQUENCE nombre_secuencia
[ INCREMENT BY n ]
[ START WITH n ]
[{ MAXVALUE n | NOMAXVALUE }]
[{ MINVALUE n | NOMINVALUE }]
[{ CYCLE | NOCYCLE }]
[{ CACHE n | NOCACHE }]
Sólo el creador ó un usuario con el permiso ALTER SEQUENCE puede modificar la secuencia.
No se puede modificar el número de inicio de la secuencia ( START WITH.).
Cuando se modifica una secuencia se realizan algunas validaciones ( por ejemplo, el nuevo
MAXVALUE no puede ser menor que el valor actual de la secuencia ).
Borrar una secuencia
DROP SEQUENCE nombre_secuencia

Sólo el creador de la secuencia ó un usuario con el privilegio DROP ANY SEQUENCE puede borrar la
secuencia.
Índices
CREATE [ UNIQUE ] INDEX nombre_indice

ON nombre_tabla ( columna1,columna2,...)
El objetivo de un índice es reducir la I/O a disco utilizando un acceso directo a los datos.
Cuando se borra una tabla, todos sus índices asociados también son borrados.
Un índice puede involucrar a una columna ó a varias ( índices compuestos ).
Se pueden utilizar índices para forzar unicidad en una columna ó conjunto de columnas.
Guías para crear índices

Cada operación DML ( borrado, actualización e inserción ) que es ejecutada en una tabla con índice
provoca que el índice debe ser actualizado.
Si se quiere forzar unicidad en una columna, se debería definir una constraint de tipo UNIQUE en la
definición de la columna dentro de la tabla. Posteriormente, se creará automáticamente un índice único
sobre dicha columna.
1. No crear un índice si una tabla es actualizada frecuentemente.

2. No crear un índice si las columnas no son usadas con frecuencia en las condiciones de las
consultas ( cláusula WHERE ).
3. No crear un índice si se espera que la mayoría de las consultas devuelvan más de un 4% de
las filas.
4. No crear un índice cuando el número de filas es pequeño.
5. Crear un índice cuando la columna contiene un amplio rango de valores ó un gran número de
valores nulos.
6. Crear un índice cuando dos ó más columnas suelen usarse conjuntamente en las cláusulas
WHERE ó en las JOINs.
Eliminando un índice
DROP INDEX nombre_indice
No se pueden modificar índices.
Para poder borrar un índice debe ser el creador ó un usuario con el privilegio DROP ANY INDEX.

Sinónimos
CREATE [PUBLIC] SYNONYM sinónimo

FOR objeto
Para referirse a una tabla de otro usuario es necesario prefijar el nombre de la tabla con el nombre del
usuario que la creó. Creando un sinónimo se elimina la necesidad de cualificar el nombre del objeto
con el esquema y proporciona un nombre alternativo para la tabla, vista, secuencia, procedimiento,etc..
PUBLIC crea un sinónimo accesible a todos los usuarios
El DBA puede crear sinónimos públicos accesibles por todos los usuarios. Para que un usuario pueda
crear un sinónimo público, éste debe poseer el privilegio del sistema “CREATE PUBLIC SYNONYM“.
Borrando Sinónimos
DROP SYNONYM sinónimo
Sólo el DBA puede borrar un sinónimo público.

7. Controlando transacciones
¿ Qué es una transacción ?

Es un conjunto de sentencias DML (INSERT,UPDATE,DELETE) que forman una unidad lógica de
trabajo.
El servidor Oracle asegura la consistencia de la información ( ante fallos de procesos de usuario,
caídas del sistema, etc..) basándose en las transacciones.
Una transacción comienza cuando se ejecuta la primera sentencia SQL posterior a la finalización de la
anterior transacción y finaliza cuando:
- Se ejecuta un COMMIT ó un ROLLBACK explícito.

- Cuando se ejecuta una sentencia DDL.
- Cuando se ejecuta una sentencia DCL.
- Cuando el usuario sale de SQL*Plus ( se realiza COMMIT implícito )
- Cuando se produce una caída del sistema ( se realiza ROLLBACK implícito)
Tipos de transacciones
Tipo de transacción Descripción
DML No realizan COMMIT implícito. Es necesario realizar un
COMMIT explícito para que los cambios realizados surtan
efecto.
DDL Realizan COMMIT implícito de la actual transacción antes y
después de cada sentencia DDL.
DCL Realizan COMMIT implícito
Si una sentencia DDL no se ejecuta correctamente , no puedes echar atrás los cambios previos puesto
que un COMMIT implícito se ejecuta ANTES y DESPUÉS de ejecutar una sentencia DDL.
Notas sobre el COMMIT y ROLLBACK

COMMIT:
Hasta que no se realiza un COMMIT, sólo el usuario que está realizando las modificaciones podrá ver
el efecto que están surtiendo sobre las tablas afectadas, el resto de los usuarios verán la información
antigua ( la existente en el segmento de Rollback ).
Las filas afectadas por las operaciones de un usuario ( INSERT,UPDATE,DELETE ) son bloqueadas.
Otros usuarios no pueden acceder a dichas filas hasta que no finalice la transacción.

El COMMIT afecta sólo a la transacción del usuario que ejecuta el COMMIT ( no afecta a
transacciones de otros usuarios ).
ROLLBACK:
Una sentencia ROLLBAC ( al igual que un COMMIT ) puede ser usado en un subprograma PL / SQL.
Esto ofrece una gran ventaja cuando se usan estructuras lógicas del tipo if-then-else, puesto que
permiten modificar y borrar información de forma condicional en base a condiciones en tiempo de
ejecución.
Sentencias de Control Explícito de Transacciones

Sentencia Descripción
COMMIT Finaliza la actual transacción haciendo
definitivos los cambios de datos pendientes.
SAVEPOINT nombre Establece una marca en la actual
transacción.
ROLLBACK [ TO SAVEPOINT nombre] Finaliza la actual transacción deshaciendo
todos los cambios pendientes. ( ROLLBACK
TO SAVEPOINT name, elimina la marca
‘name’ y todos los cambios realizados
posteriormente al establecimiento de la
misma ).
Nota1: Si se crea un segundo SAVEPOINT con el mismo nombre que uno anterior, el primero ( el más
antiguo ) se elimina.
Nota2: Si una sentencia DML falla al ejecutarse, sólo se realiza rollback de dicha sentencia ( rollback
implícito ), pero los cambios realizados anteriormente a la ejecución de la sentencia que ha producido
el error no serán desechos.
Consistencia en Lectura
El propósito de la consistencia en lectura es asegurar que cada usuario ve la información cómo estaba
después del último COMMIT realizado.
La consistencia en lectura es realizada por el Servidor Oracle y es transparente al usuario. Oracle

guarda una copia de la base de datos en el segmento de Rollback.
Cuando se realiza un INSERT, UPDATE ó DELETE sobre la BD, el Servidor Oracle guarda un copia
de los datos en el Segmento de Rollback antes de su modificación.
Todos los usuarios, excepto el que está realizando los cambios verá la BD como estaba antes de que
se realizaran los cambios: Ellos ven una “foto” (snapshot) de los datos existentes en el segmento de
Rollback.

Bloqueos
Los bloqueos son mecanismos que previenen de destruir modificaciones entre transacciones de
usuario que están accediendo al mismo recurso.
Los bloqueos son transparentes al usuario. Oracle, por defecto, utiliza el más bajo nivel de restricción
en cuanto a los bloqueos, permitiendo un mayor grado de concurrencia.
Los usuarios también pueden bloquear datos explícitamente.
Modos de bloqueo
Modo de bloqueo Descripción
Exclusivo Bloquea un recurso de manera exclusivo. Solo esa transacción
puede alterar el recurso. Se realiza en sentencias del tipo
INSERT,UPDATE,DELETE
Compartido Varias transacciones pueden adquirir bloqueos compartidos del
mismo recurso
Todos los bloqueos adquiridos por una sentencia dentro de una transacción son mantenidos hasta el
final de la transacción.
Los bloqueos adquiridos después de un SAVEPOINT son liberados cuando se hace ROLLBACK hasta
ese punto.
Bloqueos explícitos
SELECT FOR UPDATE: Ejecuta la consulta identificando las filas que serán actualizadas ó borradas y
bloqueando, por tanto, las filas seleccionadas.
NOWAIT: Finaliza la sentencia si alguna de las filas que se quiere modificar está bloqueada por otra
transacción ( No espera indefinidamente ).
LOCK TABLE: Bloquea una tabla. Cuando se usa con vistas, bloque la tabla base de la vista.
Ejemplo:
SQL> SELECT empno,ename,sal

2 FROM emp
3 WHERE deptno=30
4 FOR UPDATE NOWAIT;  Bloquea las filas devueltas por el SELECT
EMPNO ENAME SAL

----- ---------- ---------
7499 ALLEN 1600,00
7521 WARD 1250,00
7654 MARTIN 1250,00
7698 BLAKE 2850,00
7844 TURNER 1500,00
7900 JAMES 950,00

6 rows selected
SQL>

8. CONTROL DE ACCESO DE USUARIOS A LA BD
La seguridad en la BD puede ser clasificada en 2 categorías:
a) A nivel de Sistema: Cubre usos y accesos a nivel de sistema, tales como control de
usuarios y password, espacio en disco alocado por los usuarios, operaciones del sistema
permitidas por los usuarios.
b) A nivel de la Base de Datos: Cubre usos y accesos a nivel de objetos de la BD, y determina
qué acciones pueden realizar los usuarios sobre los objetos de la BD.
El DBA es un usuario de “alto nivel” que tiene la posibilidad de conceder acceso a los usuarios a la
Base de Datos y a sus objetos. Los usuarios necesitan privilegios del sistema para poder acceder a
la BD y privilegios de objeto para poder manipular el contenido de los objetos de la BD.
Existe la posibilidad que un usuario pueda conceder permisos (privilegios) a otros usuarios ó a Roles
(conjunto de privilegios relacionados).
Creando usuarios
CREATE USER usuario

IDENTIFIED BY password
Ejemplo:
SQL> CREATE USER ALFREDO  Login

2 IDENTIFIED BY Liqui1;  Password
User CREATED
SQL>
Una vez que el DBA ha creado un usuario, éste no posee ningún privilegio. Así, el DBA debe
comenzar a conceder los privilegios necesarios al nuevo usuario creado para que éste pueda ser
operativo.
Modificando la password de usuarios
ALTER USER usuario

IDENTIFIED BY nueva_password
Cada usuario puede cambiar su password haciendo uso de la sentencia ALTER USER. Para cambiar
la password no se necesita tener el permiso ALTER USER, aunque sí para cambiar otras
características relacionadas con el usuario.

Para cambiar la password, se necesita conocer la anterior ( porque de lo contrario, no podríamos
establecer sesión en la BD ). En tal caso, el DBA ó un usuario con el privilegio del sistema “ALTER
USER” nos podría crear una nueva password.
Ejemplo:
SQL> ALTER USER ALFREDO  Login

2 IDENTIFIED BY Liqui2;  Nueva Password
User CREATED
SQL>
Privilegios del Sistema ( System Privileges )

Los privilegios del sistema suelen proporcionados a los usuarios por el DBA. Los privilegios del
sistema, más comunes, concedidos a los usuarios son:
System Privileges Operaciones autorizadas

CREATE SESSION Permite conectar a la BD
CREATE TABLE Permite crear tablas en el esquema del usuario
CREATE SEQUENCE Permite crear secuencias en el esquema del usuario
CREATE VIEW Permite crear vistas en el esquema del usuario
CREATE PROCEDURE Permite crear procedimientos, funciones y paquetes en el
esquema del usuario
Concediendo privilegios del sistema
GRANT privilegio1 [,privilegio2,….]

TO user1 [, user2,.…..]
El DBA utiliza la sentencia GRANT para conceder permisos a los usuarios.
Ejemplo:
SQL> GRANT CREATE TABLE,CREATE SEQUENCE,CREATE PROCEDURE,CREATE VIEW

2 TO Alfredo;
Grant succeeded.
SQL>
Privilegios de Objetos ( Objects Privileges )

Los privilegios de objeto actúan sobre objetos ( tablas, vistas, secuencias, procedimientos,....). Cada
objeto tiene un conjunto particular de permisos que se pueden conceder sobre él.
Object Privileges Tabla Vista Secuencia Procedure

ALTER(*) X X
DELETE X X
EXECUTE X
INDEX X
INSERT X X
REFERENCES X
SELECT X X
UPDATE X X
(*) El CREATE es un SYSTEM PRIVILEGE y el ALTER un OBJECT PRIVILEGE
Los permisos UPDATE, REFERENCES e INSERT puede ser restringidos a un subconjunto de

columnas.
Un GRANT sobre un sinónimo es convertido a un GRANT sobre la tabla base referenciada por el
sinónimo.
Los privilegios INDEX y REFERENCES no pueden ser concedidos a roles
Concediendo privilegios de objeto
GRANT [ALL[ PRIVILEGES]] | object_privil1,object_privil2 [(columna1,columna2,..).]

ON objeto
TO { usuario1,usuario2,..| rol1,rol2,... | PUBLIC }
[ WITH GRANT OPTION ];
Un usuario automáticamente tiene todos los privilegios sobre los objetos de su esquema.
ALL PRIVILEGES: Concede todos los privilegios del objeto
PUBLIC: Concede el privilegio de objeto a todos los usuarios. Para poder conceder este permiso, el
usuario debe ser el propietario del objeto ó haber recibido el privilegio con la cláusula WITH GRANT
OPTION
WITH GRANT OPTION: Permite al usuario que recibe el permiso poder concedérselo a otros usuarios.
Para poder conceder permisos sobre un objeto tú debes ser el propietario ó haber recibido el permiso
sobre el objeto con la opción WITH GRANT OPTION
Privilegios concedidos con la opción WITH GRANT OPTION son revocados cuando se revoca el
privilegio al usuario que nos ha concedido el permiso.

¿ Qué es un Rol ?
Un rol es un conjunto de privilegios relacionados a los que se le da un nombre. Un rol puede ser
concedido a un usuario. Un usuario puede tener acceso a varios roles, y varios usuarios pueden tener
concedido el mismo rol.
En primer lugar, el DBA debe crear el rol. Después conceder privilegios al rol creado y finalmente
conceder el rol creado a los usuarios.
CREATE ROLE nombre_role
Ejemplo:
SQL> CREATE USER ALFREDO  Creación de usuario

2 IDENTIFIED BY Liqui1;
User CREATED
SQL> CREATE ROLE desarrollador;  Creación de rol
Role CREATED
SQL> GRANT CREATE PROCEDURE TO desarrollador;  Concesión de permisos al rol
Grant succeeded
SQL> GRANT desarrollador TO usuario1;  Concesión de rol a usuario
Grant succeeded
SQL>
Eliminando permisos
REVOKE { privilegio1 [ ,privilegio2,...] | ALL

ON objeto
FROM { usu1[,usu2,...] | role1,..| PUBLIC
[ CASCADE CONSTRAINTS ]
Cuando se usa la sentencia REVOKE, se elimina el privilegio que se especifica sobre el usuario que
se indica y sobre otros usuarios que recibieron el permiso del usuario al cual le estamos eliminando el
privilegio.
CASCADE CONSTRAINTS: Elimina cualquier constraint de integridad referencial hecho al objeto

gracias a la posesión del privilegio REFERENCES.
Sólo pueden revocar permisos los usuarios que lo dieron y el DBA.

9. Diccionario de Datos
El diccionario de datos es un conjunto de tablas que guardan toda la información relacionada con los
objetos de la BD. Únicamente el usuario SYS tiene permisos para modificar tales tablas. Los usuarios
de la BD pueden consultar cierta información a través de vistas. Algunas de las más utilizadas se listan
a continuación.
- USER_TABLES: Tablas propiedad del usuario ( subconjunto de USER_OBJECTS ).

- USER_OBJECTS: Todos los objetos propiedad del usuario.
- USER_CATALOG: Tablas, vistas, sinónimos y secuencias propiedad del usuario ( subconjunto de
USER_OBJECTS). Esta vista tiene un sinónimo llamado ‘CAT’.
- USER_CONSTRAINTS: Todas las constraints asociadas a tablas propiedad del usuario.
- USER_CONS_COLUMNS: Todos los nombres de las columnas involucradas en constraints
asociadas a tablas propiedad del usuario.
- USER_COL_COMMENTS: Comentarios sobre columnas asociadas a tablas propiedad del usuario.
- ALL_COL_COMMENTS: Comentarios sobre columnas asociadas a tablas a las que el usuario
tiene acceso.
- ALL_TAB_COMMENTS: Comentarios sobre tablas a las que el usuario tiene acceso.
- USER_TAB_COMMENTS: Comentarios sobre tablas propiedad del usuario.
- USER_VIEWS: Vistas creadas por el usuario.
- USER_SEQUENCES: Secuencias creadas por un usuario.
- USER_INDEXES: Nombre de los índices creados por un usuario.
- USER_IND_COLUMNS: Nombre de las columnas que componen los índices creados por el
usuario.
- ROL_SYS_PRIVS: Privilegios del sistema concedidos a roles.
- ROLE_TAB_PRIVS: Privilegios sobre tablas concedidos a roles.
- USER_ROLE_PRIVS: Roles accesibles por el usuario.
- USER_TAB_PRIVS_MADE: Privilegios de objeto concedidos.
- USER_TAB_PRIVS_RECD: Privilegios de objeto recibidos.
- USER_COL_PRIVS_MADE: Privilegios de objeto concedidos sobre columnas.
- USER_COL_PRIVS_RECD: Privilegios de objeto recibidos sobre columnas.
- ALL_COL_PRIVS_RECD: Privilegios de objeto recibidos sobre columnas por el usuario, PUBLIC ó
role accesible.
- ALL_IND_COLUMNS: Columnas que componen los índices de tablas accesibles por el usuario.
- ALL_INDEXES: Descripción de índices en tablas accesibles por el usuario.
- DBA_INDEXES: Descripción de todos los índices de la BD.
En general:
ALL_xxx: Las vistas del diccionario de datos prefijadas con ‘ALL’ visualizan nombres de objetos en los
cuales el usuario tiene acceso. Estas vistas incluyen toda la información existente en las vistas del tipo

‘USER_’ más información sobre objetos que no pertenecen al usuario pero que éste tiene acceso a
ellos.
USER_xxx: Las vistas del diccionario de datos prefijadas con ‘USER’ visualizan información de
objetos propiedad del usuario.
DBA_xxx: Las vistas del diccionario de datos prefijadas con ‘DBA’ visualizan información de todos los
objetos de la BD independientemente del propietario.
V$_xxx: Las vistas del diccionario de datos que comienzan por ‘V$’, visualizan información del
rendimiento de los objetos de la BD.

Anexo A: SQL* Plus
- SQL* Plus es una herramienta Oracle que reconoce y ejecuta sentencias SQL contra el Servidor
de Oracle. Además, contiene su propio lenguaje de comandos.
- SQL*Plus permite crear Reports ( informes ) interactivos  Su contenido depende de los valores
introducidos por el usuario en tiempo de ejecución. Para poder realizarlo, el usuario puede
“embeber” variables de sustitución en sentencias SQL.
- Características:
o Reconoce sentencias SQL y las envía al Servidor

o Acepta sentencias SQL almacenadas en ficheros.
o Tiene sentencias para configurar el entorno.
o Permite acceder a bases de datos locales y remotas.
o Los comandos SQL*Plus no se almacenan en el buffer SQL.
o Los comandos SQL*Plus pueden abreviarse.
o Los comandos SQL*Plus no permiten manipular datos de la BD.
o Si el comando SQL*Plus ocupa más de una línea se puede indicar un ‘-‘ al final de la línea
actual y continuar en la siguiente.
o No requiere un carácter terminador ( los comandos son ejecutados inmediatamente).
o Permite generar informes en base a resultados de consultas.
o Permite crear bloques anónimos, procedimientos, funciones y triggers usando PL/SQL.
o Permite crear ficheros de script para almacenar sentencias SQL.
Visualizar la estructura de una tabla:
DESC[RIBE] <tabla/vista> : Visualiza la estructura de una tabla ó vista ( visualiza los nombres de las
columnas, sus tipos y la obligatoriedad de ser informadas ).
Particularizar el entorno SQL*Plus:
SET variable_sistema valor
El comando SET permite establecer ciertos valores a parámetros que controlan el entorno en el cual
está SQL*Plus operando (sobre nuestra sesión actual).
SET VERIFY ON/OFF: Ejecutando el comando SET VERIFY ON se fuerza a SQL*Plus a visualizar el
texto del comando antes y después de remplazar las variables de sustitución con los valores
introducidos.
SET AUTOCOMMIT ON/OFF: Si se establece a ON, cada sentencia que se ejecuta realizará un
COMMIT implícito. Si se establece a OFF, es necesario realizar un COMMIT explícito
( para las sentencias DML )

SHOW variable_sistema (una vble propia de SQL*Plus)
Muestra el valor actual de cierta variable del sistema
Ejemplo:
SQL > SHOW AUTOCOMMIT
Definiendo Variables de usuario:
Se pueden definir / declarar variables antes de ejecutar sentencias SELECT. SQL*Plus proporciona 2
comandos para definir variables de usuario: ACCEPT y DEFINE.
Comando Descripción
ACCEPT Almacena en una variable un dato introducido por el usuario
DEFINE variable = valor Crea una variable de tipo CHAR y le asigna un valor
DEFINE variable Visualiza la variable, su valor y su tipo de dato
DEFINE Visualiza todas las variables de usuario junto con sus valores y tipos
de dato
ACC[EPT] nombre_variable [tipo_de_dato] [FOR[MAT] formato]

[DEF[AULT] valor_por_defecto]
[PROMPT texto | NOPR[OMPT]] [HIDE]
Si ‘nombre_variable’ no existe en el momento de ejecutar la sentencia ACCEPT, SQL*Plus la crea.

‘Tipo_de_dato’ puede ser CHAR,NUMBER ó DATE.
FOR[MAT] especifica un modelo de formato ( ej: A10 ó 9.999)
[DEF[AULT] establece un valor por defecto a la variable si no se da respuesta al comando ACCEPT.
La respuesta debe ser dada en el formato especificado, si éste ha sido definido.
NOPR[OMPT] salta de línea y espera la introducción de un valor por parte del usuario sin que se
muestre un mensaje al usuario.
HIDE oculta los valores que está introduciendo el usuario ( válido para passwords ).
DEFINE: Se puede usar el comando DEFINE para crear una variable de tipo CHAR. Una variable
permanece definida hasta que usas el comando UNDEFINE ( UNDEFINE nombre_variable ) ó sales
de SQL*Plus.
Ejemplo:
DEFINE _EDITOR=”edit.exe”
Ejemplo:
SQL> DEFINE vble1 = 10

SQL> select * from emp where deptno=&vble1;

----- ---------- --------- ----- ----------- --------- --------- ------
7782 CLARK MANAGER 7839 09/06/81 2450,00 10
7839 KING PRESIDENT 17/11/81 5000,00 10
7934 MILLER CLERK 7782 23/01/82 1300,00 10
SQL> UNDEFINE vble1

SQL> DEFINE vble1 = 20
SQL> select * from emp where deptno=&vble1;

----- ---------- --------- ----- ----------- --------- --------- ------
7369 SMITH CLERK 7902 17/12/80 800,00 20
7566 JONES MANAGER 7839 02/04/81 2975,00 20
7788 SCOTT ANALYST 7566 19/04/87 3000,00 20
7876 ADAMS CLERK 7788 23/05/87 1100,00 20
7902 FORD ANALYST 7566 03/12/81 3000,00 20
SQL>
Una vez definida una variable SQL*Plus permanece mientras dure la sesión ó hasta el que usuario
realiza un UNDEFINE de la variable.
En SQL*Plus puedes utilizar variables de sustitución (& ó &&) para almacenar temporalmente valores.
Puedes predefinir variables SQL*Plus usando los comandos ACCEPT y DEFINE.
Las variables de sustitución pueden sustituir:
a) Una condición WHERE

b) Una cláusula ORDER BY
c) Una expresión de columna
d) Un nombre de tabla
e) Una sentencia SELECT completa
&variable_de_usuario: Si la variable no existe, se indicará un mensaje al usuario para que introduzca

un valor para dicha variable.
&&variable_de_usuario: Si la variable no existe, se indicará un mensaje al usuario para que

introduzca un valor para dicha variable. El valor introducido será utilizado de nuevo en cualquier lugar
en el que se referencie de nuevo a la variable sin que el usuario reciba un nuevo mensaje.
Cuando las variables de sustitución contengan valores fecha ó caracteres deben ser encerradas entre
comillas simples.
Ejemplo:
......
WHERE job = ‘&job_title’
Comandos de edición:

A[PPEND] texto : Añade texto al final de la fila actual.
C[HANGE] / cadena_old / cadena_new: Cambia cadena_old por cadena_new en la fila actual.
C[HANGE] / cadena /: Borra cadena de la fila actual
CL[EAR] BUFF[ER]: Limpia el buffer.
DEL: Borra la línea actual.
DEL n: Borra la línea n
DEL m n : Borra un rango de líneas ( de la m a la n ).
I[INPUT] : Inserta un número indefinido de líneas.
I[INPUT] texto: Inserta una línea conteniendo el texto
L[IST]: Lista todas las líneas del SQL Buffer.
L[IST] n: Lista la línea ‘n’ del SQL Buffer.
L[IST] m n: Lista un conjunto de líneas ( desde la ‘m’ a la ‘n’ ).
R[UN]: Visualiza y ejecuta la sentencia SQL que actualmente está en el buffer.
n: Especifica la línea que se convertirá en la línea actual.
n cadena: Reemplaza la línea ‘n’ con cadena.
0 cadena: Inserta una línea antes de la línea 1 que contiene cadena
Comandos de tratamiento de ficheros:
SAV[E] nombre_fichero[.ext] [REP[LACE APP[END]]: Guarda el contenido actual del SQL Buffer en
un fichero. Se puede usar APPEND para anexar a un fichero ya existente. Se usará REPLACE para
sobrescribir un fichero existente. La extensión de los ficheros es, por defecto, ‘.sql’
GET nombre_fichero[.ext]: Escribe el contenido de un fichero en el SQL Buffer.
STA[RT] nombre_fichero[.ext]: Ejecuta el fichero de comandos pasado por parámetro.
@nombre_fichero[.ext] : Similar a START.
ED[IT]: Invoca al editor y salva el contenido del SQL Buffer en un fichero llamado “afiedt.buf”.
ED[IT] [nombre_fichero[.ext]]: Invoca al editor para editar un fichero guardado.
SPO[OL] [nombre_fichero[.ext]] | OFF|OUT]: Almacena los resultados de las consultas en un fichero.

OFF cierra el fichero de Spool. OUT cierra el fichero de Spool y envía el contenido a la impresora.
EXIT: Abandona SQL*Plus
Notas:
- El comando DEFINE se utilizará para actualizar los valores de las variables de entorno.
- Si presionas la tecla ENTER, antes de completar una sentencia, SQL*Plus te mostrará el siguiente
número de línea. Esto es lo que se conoce como SQL Buffer.
- En el SQL Buffer sólo se puede almacenar una sentencia a la vez.

- Para cerrar el buffer se puede introducir uno de las caracteres terminadores (‘;’ que se puede
colocar en cualquier lugar ó ‘/’ que tiene que colocarse al principio de la línea ) ó bien, pulsar dos
veces la tecla ENTER.
- Para ejecutar la sentencia incluida en el buffer utilizaremos el comando RUN ( R ).
- SQL*Plus ignora espacios en blanco antes y después de operadores aritméticos ( es decir,

“ename + 1” es igual a “ename+1” )

Anexo B: Ficheros de Configuración
Init.ora: Configura parámetros usados para arrancar una instancia de la BD
Login.sql : Fichero que configura aspectos para una sesión SQL*Plus. Se pueden definir valores para
ciertas variables y de esta forma parametrizar la sesión.
Config.ora: Es un fichero que contiene características de comunicaciones en redes Cliente/Servidor.
En Madrid, a 24 de Mayo de 2002.

Idioma

¡Te damos la bienvenida a Scribd!

Resumen OCA Primer Examen

Cargado por

Información del documento

Fecha en que fue cargado

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Descripción:

Copyright:

Formatos disponibles

Resumen OCA Primer Examen

Cargado por

Descripción:

Copyright:

Formatos disponibles

Títulos relacionados

Oracle Certified Associate

Alfredo González Naranjo

Versión Fecha Autor Comentario

© Alfredo González Naranjo Página 2 de 66

© Alfredo González Naranjo Página 3 de 66

© Alfredo González Naranjo Página 4 de 66

© Alfredo González Naranjo Página 5 de 66

Fundamentos de la sentencia SELECT

SELECT [ DISTINCT | ALL ] { *, columna1 [ alias1 ], ….,expr1,….. }

SQL> SELECT DISTINCT JOB FROM emp;

© Alfredo González Naranjo Página 6 de 66

Nota2: Cuando en una sentencia SELECT se utiliza un GROUP BY y un ORDER BY a la vez,

La cláusula WHERE admite dos tipos de operadores de comparación:

o Lógicos: >, < ,= ,<> ,!= ,..

o SQL: IS NULL, IS NOT NULL, (<exp1>,<exp2>,<exp3>,..) IN (val1,val2,val3,..), LIKE,

SQL> SELECT * FROM EMP

SQL> SELECT * FROM emp

 mgr es de tipo NUMBER

Nota5: Las sentencias de tipo ‘campo1 IN (x1,x2,...,xN )’ se transforman internamente en:

© Alfredo González Naranjo Página 7 de 66

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

SQL> SELECT empno,ename,SQRT(sal+comm*2.5) FROM emp ORDER BY 3;

EMPNO ENAME SQRT(SAL+COMM*2.5)

SQL> SELECT DISTINCT JOB,MGR FROM EMP

Los caracteres comodín para la cláusula LIKE son:

© Alfredo González Naranjo Página 8 de 66

La cláusula LIKE tiene una sintaxis del tipo:

LIKE ‘patron’ [ ESCAPE ‘caracter_escape’ ]

SQL> SELECT * FROM tabla1

Justificaciones por defecto:

Tipo de dato Justificación por defecto

Operadores lógicos negados:

© Alfredo González Naranjo Página 9 de 66

SQL> SELECT ename,job,ROWNUM,ROWID FROM emp;

ENAME JOB ROWNUM ROWID

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

SQL> SELECT * FROM emp WHERE ROWNUM>1;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

Si todos los operadores de la expresión tienen la misma prioridad, se evaluarán de izquierda a

© Alfredo González Naranjo Página 10 de 66

Tratando valores NULL

SQL> CREATE TABLE ALFREDO1

SQL> DESC ALFREDO1

SQL> SELECT * FROM EMP WHERE EMPNO;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

SQL> SELECT ENAME AS NOMBRE,SAL*12+COMM AS SUELDO FROM EMP;

Igualmente, cualquier comparación con valores NULL siempre es FALSE.

© Alfredo González Naranjo Página 11 de 66

Si expr1 es NULL, entonces se devuelve expr2. En caso contrario, se devuelve expr1.

Tipo de Dato Función Valor devuelto si expr1 es NULL

SQL> SELECT ENAME,COMM,NVL(SQRT(COMM),'0')AS RAIZ FROM EMP;

ENAME COMM RAIZ

Definir Alias de Columna

SQL> SELECT ename AS nombre FROM EMP;

NOMBRE Aparece en mayúsculas, por defecto

© Alfredo González Naranjo Página 12 de 66

SQL> SELECT ename nombre FROM EMP;  La cláusula AS no es necesaria

SQL> SELECT ename "Nombre de Pila$" FROM EMP;