Resumen OCA Primer Examen

Oracle Certified Associate

( OCA )

Examen 1

Introducción a SQL

Alfredo González Naranjo

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

Control de documentación

Versión Fecha Autor Comentario

1.0 24/02/2002 AGN Creación inicial


Índice

0. INTRODUCCIÓN.................................................................................................................................5

1. LA SENTENCIA SELECT DE ORACLE..........................................................................................6

FUNDAMENTOS DE LA SENTENCIA SELECT............................................................................................6USANDO PSEUDOCOLUMNAS....................................................................................................................9EXPRESIONES ARITMÉTICAS...................................................................................................................10TRATANDO VALORES NULL..................................................................................................................11FUNCIÓN NVL.......................................................................................................................................11DEFINIR ALIAS DE COLUMNA................................................................................................................12USO DEL OPERADOR DE CONCATENACIÓN.............................................................................................13JOIN.......................................................................................................................................................13

2. FUNCIONES DE FILA.......................................................................................................................16

FUNCIONES DE FILA:..............................................................................................................................16FECHAS EN ORACLE...............................................................................................................................17FUNCIONES DE CONVERSIÓN.................................................................................................................20FUNCIÓN DECODE...............................................................................................................................24

3. USANDO OPERADORES DE CONJUNTOS.................................................................................25

4. CREACIÓN DE SUBCONSULTAS..................................................................................................28

OPERADOR EXISTS / NOT EXISTS.....................................................................................................31UPDATE SINCRONIZADO.......................................................................................................................32DELETE SINCRONIZADO.......................................................................................................................32

5. CREACIÓN DE TABLAS..................................................................................................................33

OBJETOS DE UNA BD ORACLE...............................................................................................................33¿ QUÉ ES UN ESQUEMA ?........................................................................................................................33LA SENTENCIA CREATE TABLE.........................................................................................................34TIPOS DE DATOS UTILIZABLES EN COLUMNAS.......................................................................................34CONSTRAINTS EN UN CREATE TABLE...............................................................................................35CONSTRAINT NOT NULL......................................................................................................................36CONSTRAINT CHECK............................................................................................................................36CONSTRAINT PRIMARY KEY..............................................................................................................37CONSTRAINT UNIQUE..........................................................................................................................37CONSTRAINT FOREIGN KEY...............................................................................................................38CREAR TABLAS BASÁNDOSE EN CONSULTAS.........................................................................................39ALTERAR UNA TABLA............................................................................................................................39CAMBIAR EL NOMBRE DE UN OBJETO....................................................................................................42TRUNCANDO UNA TABLA.......................................................................................................................42BORRANDO UNA TABLA.........................................................................................................................42AÑADIENDO COMENTARIOS A UNA TABLA.............................................................................................43


6. OTROS OBJETOS DE LA BD..........................................................................................................44

VISTAS....................................................................................................................................................44CREACIÓN DE UNA VISTA.......................................................................................................................44REGLAS PARA EJECUTAR OPERACIONES DML EN UNA VISTA...............................................................46MODIFICANDO UNA VISTA......................................................................................................................46BORRANDO UNA VISTA..........................................................................................................................47SECUENCIAS...........................................................................................................................................47PSEUDOCOLUMNAS NEXTVAL Y CURRVAL.....................................................................................48ÍNDICES..................................................................................................................................................50GUÍAS PARA CREAR ÍNDICES..................................................................................................................50ELIMINANDO UN ÍNDICE.........................................................................................................................50SINÓNIMOS.............................................................................................................................................51BORRANDO SINÓNIMOS..........................................................................................................................51

7. CONTROLANDO TRANSACCIONES............................................................................................52

¿ QUÉ ES UNA TRANSACCIÓN ?..............................................................................................................52TIPOS DE TRANSACCIONES.....................................................................................................................52NOTAS SOBRE EL COMMIT Y ROLLBACK.........................................................................................52SENTENCIAS DE CONTROL EXPLÍCITO DE TRANSACCIONES..................................................................53CONSISTENCIA EN LECTURA..................................................................................................................53BLOQUEOS..............................................................................................................................................54MODOS DE BLOQUEO..............................................................................................................................54BLOQUEOS EXPLÍCITOS..........................................................................................................................54

8. CONTROL DE ACCESO DE USUARIOS A LA BD......................................................................56

CREANDO USUARIOS..............................................................................................................................56MODIFICANDO LA PASSWORD DE USUARIOS..........................................................................................56PRIVILEGIOS DEL SISTEMA ( SYSTEM PRIVILEGES )..............................................................................57CONCEDIENDO PRIVILEGIOS DEL SISTEMA.............................................................................................57PRIVILEGIOS DE OBJETOS ( OBJECTS PRIVILEGES )...............................................................................58CONCEDIENDO PRIVILEGIOS DE OBJETO.................................................................................................58¿ QUÉ ES UN ROL ?................................................................................................................................59ELIMINANDO PERMISOS..........................................................................................................................59

9. DICCIONARIO DE DATOS..............................................................................................................61

ANEXO A: SQL* PLUS.........................................................................................................................63

Anexo B: Ficheros de Configuración........................................................................................................68


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---------ANALYSTCLERKMANAGER

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+MGRANALYST CLERK 7698CLERK 7782CLERK 7788CLERK 7902MANAGER 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 7566ANALYST CLERK 7698CLERK 7902MANAGER 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 tabla12 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 ESCAPESi 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 defectoNUMBER DerechaCHAR IzquierdaVARCHAR2 IzquierdaDATE Izquierda

Operadores lógicos negados:

Operador DescripciónNOT columna1 = No es igual aNOT 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 AAAAcUAACAAAAEbAAAALLEN SALESMAN 2 AAAAcUAACAAAAEbAAB

SQL> SELECT * FROM emp WHERE ROWNUM<2; devuelve sólo la primera fila

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------ 7369 SMITH CLERK 7902 17/12/80 800,00 20

SQL> SELECT * FROM emp WHERE ROWNUM>1;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------

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 columnasb) Constantes numéricasc) 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 ALFREDO1Name 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;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------ 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 NULLNUMBER 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 0ALLEN 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----------SMITHALLEN .....


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

NOMBRE----------SMITHALLEN

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

Nombre de Pila$ Con espacios ó caracteres especiales se utilizan “ “ --------------SMITHALLEN

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 concatenaALLEN 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.DEPTNOFROM EMP E,DEPT DWHERE 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 filab) 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;

Name Type Nullable Default Comments ----- ----------- -------- ------- -------- 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ónDATE + NUMBER DATE Suma un número de días a la fechaDATE – NUMBER DATE Resta un número de días de la fechaDATE – 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 21ALLEN 25WARD 20

Funciones de Fecha:

Función DescripciónMONTHS_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 AVARCHAR2 ó CHAR (*) NUMBERVARCHAR2 ó CHAR (*) DATENUMBER VARCHAR2DATE 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 ObjetivoTO_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ónSCC ó 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ñoY,YYY Año con una coma en la posición indicadaIYYY,IYY,IY,I Los 4,3,2 y 1 últimos dígitos del año en estándar ISOSYEAR ó 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 CristoQ Cuarto de año ( número de trimestre )MM Mes, con dos dígitos


MONTH Mes en letrasMON 3 letras representativas del mesRM Mes en números romanosWW ó W Semana del año ó del mesDDD ó DD ó D Día del año, ó mes, ó semanaDAY Día de la semana en letrasDY 3 letras representativas del día de la semanaJ Día Juliano

Elementos de formato para horas:

Elemento DescripciónAM ó PM Antes del mediodía ó despuésA.M. ó P.M. Antes del mediodía ó después, con puntosHH ó HH12 ó HH24 Hora del díaMI MinutosSS SegundosSSSS Segundos transcurridos desde las 00:00/.,: Signos de puntuación incluidos en la fecha“cadena” La cadena es reproducida tal cualTH 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:

Elemento Descripción9 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úmeroL 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 indicadaMI 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íficaV Devuelve un valor multiplicado por 10n dónde ’n’ es el número de 9s después de la VB 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 entre0-49 50-99

Últimos dos dígitos del año actual en el sistema

0-49 La fecha devuelta está en el SIGLO ACTUAL

La fecha devuelta está en el SIGLO ANTERIOR al actual

50-99 La fecha devuelta está en el SIGLO POSTERIOR al actual

La fecha devuelta 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 ResultadoINTERSECT Combina los resultados de dos consultas y devuelve aquellas filas de la

primera que existen al menos una vez en la segundaUNION 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 0ADAMS 7876 CLERK..

SQL> select ename,empno from emp 2 union all 3 select dname,deptno from dept;

ENAME EMPNO-------------- ----------SMITH 7369ALLEN 7499WARD 7521


JONES 7566…

SQL> select ename,empno from emp 2 intersect 3 select dname,deptno from dept;

ENAME EMPNO-------------- ----------

SQL> select ename,empno from emp 2 minus 3 select dname,deptno from dept;

ENAME EMPNO-------------- ----------ADAMS 7876ALFREDO 8000ALLEN 7499BLAKE 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 tabla1WHERE 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 deIN (*) Compara un valor con cada valor devuelto por la subconsultaANY (*)/ SOME (*)

Compara un valor con cada valor devuelto por la subconsulta y evalúa a 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:

SQL> SELECT * FROM emp 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 )

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------ 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

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

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------

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----------SCOTTKINGFORD

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 10FORD 3000,00 20SCOTT 3000,00 20JONES 2975,00 20ALLEN 1600,00 30BLAKE 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,00MARTIN 30 1250,00 1400,00TURNER 30 1500,00 0,00ALLEN 30 1600,00 300,00BLAKE 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

SQL> CREATE TABLE tabla42 ("GROUP BY" VARCHAR2(10)); Se pueden utilizar palabras reservadas

TABLE CREATED

SQL> DESC tabla3;Name Type Nullable Default Comments


-------------- --------- -------- ------- -------- Antoñito Bueno NUMBER(3) Y El campo se crea idéntico a la definición

SQL> DESC tabla4;Name Type Nullable Default Comments -------- ------------ -------- ------- -------- 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ónVARCHAR2(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 horaLONG Cadenas de caracteres de longitud variable de hasta 2 GbRAW(tamaño) Datos binarios de longitud máxima ‘tamaño’


LONG RAW Datos binarios de longitud variable de hasta 2 GbCLOB Cadenas de caracteres de hasta 4 GbBLOB Datos binarios de hasta 4 GbBFILE 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 TablaNOT NULL Especifica que la columna no puede contener valores

nulosX

UNIQUE Especifica que una columna ó conjunto de columnas deben tener valores únicos para todas las filas de la tabla

X X

PRIMARY KEY Identifica unívocamente cada fila de la tabla X XFOREIGN KEY Establece y fuerza una relación entre dos tablas X XCHECK Especifica una condición que debe cumplir los datos

de la tablaX X

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:

SQL> CREATE TABLE tabla8 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:

SQL> CREATE TABLE TABLA11 2 (campo101 number(3) PRIMARY KEY, La cláusula CONSTRAINT es opcional 3 campo102 number(5), 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:

SQL> CREATE TABLE TABLA10 2 (campo101 number(3), 3 campo102 number(5), 4 campo103 varchar2(10), 5 CONSTRAINT clave_prim PRIMARY KEY(campo101));

TABLE CREATED

SQL> CREATE TABLE TABLA11 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_tablaADD (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 TABLA1Name Type Nullable Default Comments ------- ------------ -------- ------- -------- 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

ALTER TABLE nombre_tablaADD ( [ 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:

SQL> ALTER TABLE TABLA1 2 ADD (CONSTRAINT cons_1 FOREIGN KEY(campo11) REFERENCES TABLA10(campo110));

TABLE altered

ALTER TABLE nombre_tablaMODIFY ( 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:

SQL> ALTER TABLE TABLA1 2 MODIFY (campo12 VARCHAR2(50));

TABLE altered

ALTER TABLE nombre_tablaDROP PRIMARY KEY | UNIQUE (columna) | CONSTRAINT nombre_constraint [CASCADE];

Ejemplo:

SQL> ALTER TABLE TABLA1 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.

ALTER TABLE nombre_tablaDISABLE 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

ALTER TABLE nombre_tablaENABLE 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 ComplejaNúmero de tablas Una Una ó masContiene funciones No SíContiene grupos de datos ( DISTINCT ó funciones de grupo )

No Sí

Permite sentencias DML (INSERT,UPDATE,DELETE)

Sí No siempre

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 existeFORCE: 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,66666666667RESEARCH 800 3000 2175SALES 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 grupob) Cláusula GROUP BYc) 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) Expresionesb) 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 secuenciaNOMAXVALUE: 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 secuenciaNOMINVALUE: 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áximoNOCYCLE: 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_indiceON 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ónimoFOR 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ónDML 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ónCOMMIT 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ónExclusivo 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 usuarioIDENTIFIED 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 usuarioIDENTIFIED 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 autorizadasCREATE SESSION Permite conectar a la BDCREATE TABLE Permite crear tablas en el esquema del usuarioCREATE SEQUENCE Permite crear secuencias en el esquema del usuarioCREATE VIEW Permite crear vistas en el esquema del usuarioCREATE 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 ProcedureALTER(*) X XDELETE X XEXECUTE XINDEX XINSERT X XREFERENCES XSELECT X XUPDATE 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 objetoTO { 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 objetoFROM { 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 Servidoro 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ónACCEPT Almacena en una variable un dato introducido por el usuarioDEFINE variable = valor Crea una variable de tipo CHAR y le asigna un valorDEFINE variable Visualiza la variable, su valor y su tipo de datoDEFINE 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 = 10SQL> select * from emp where deptno=&vble1;


EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------ 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 vble1SQL> DEFINE vble1 = 20SQL> select * from emp where deptno=&vble1;

EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO----- ---------- --------- ----- ----------- --------- --------- ------ 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 WHEREb) Una cláusula ORDER BYc) Una expresión de columnad) Un nombre de tablae) 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 actualCL[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 textoL[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 BDLogin.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.


Resumen OCA Primer Examen

Documents

Transcript of Resumen OCA Primer Examen