Manual SQL Oracle: Consultas, Modificación y Manipulación Datos

Manual de SQL ORACLE
1
Practicas de BB. DD.
ORACLE
Oracle Es un sistema gestor de Bases de datos relacionales, y utiliza, para consultar los datos que mantiene, el lenguaje SQL. Este lenguaje es el que se analiza a continuación, en sus tres aspectos, consulta, modificación, y manipulación de los datos. Los ejemplos que se incluyen se realizan sobre unas tablas, que corresponden a un modelo relacional sencillo, y son las siguientes:
Tabla EMP: (describe a los empleados de una empresa)
Nombre de columna Permite Tipo de Dato valores nulos? ------------------------------- ------------------ ---------------- EMPNO NOT NULL NUMBER(4) ENAME VARCHAR2(10) JOB VARCHAR2(9) MGR NUMBER(4) HIREDATE DATE SAL NUMBER(7,2) COMM NUMBER(7,2) DEPTNO NOT NULL NUMBER(2)
Tabla DEPT (describe a los departamentos de la empresa)
Nombre de columna Permite Tipo de Dato valores nulos? ------------------------------- ------------------ ---------------- DEPTNO NOT NULL NUMBER(2) DNAME VARCHAR2(14) LOC VARCHAR2(13)
Tabla SALGRADE (describe un grado de la empresa según el intervalo entre el cual se encuentra el salario del empleado)
Nombre de columna Permite Tipo de Dato valores nulos? ------------------------------- ------------------ ---------------- GRADE NUMBER LOSAL NUMBER HISAL NUMBER Toda esta información puede ser obtenida desde Oracle SQL mediante el comando "DESCRIBE nombre_tabla".
Las tablas creadas en el perfil de usuario pueden ser consultadas mediante la tabla "user_tables" y una orden de consulta sencilla, que es un

2
mandato 'SELECT'. Este mandato, es básico en la realización de consultas al sistema gestor de BBDD de Oracle, y es el que permite mostrar la información de la base de datos.
TEMA 1: Mandato "Select" Básico.
La sintaxis de este mandato es: SELECT [DISTINCT] {*, nombre_columna [alias], ....} FROM nombre_tabla [alias]; Este mandato muestra los valores incluidos en las columnas seleccionadas de la tabla especificada. Los comandos incluidos entre corchetes, son opcionales, y los incluidos entre llaves indican que ha de escogerse entre uno de ellos. Por ejemplo, la siguiente consulta: SELECT ename, job, sal FROM emp; Muestra el siguiente resultado: ENAME JOB SAL ---------- --------- --------- KING PRESIDENT 5000 BLAKE MANAGER 2850 CLARK MANAGER 2450 JONES MANAGER 2975 MARTIN SALESMAN 1250 ALLEN SALESMAN 1600 TURNER SALESMAN 1500 JAMES CLERK 950 WARD SALESMAN 1250 FORD ANALYST 3000 SMITH CLERK 800 SCOTT ANALYST 3000 ADAMS CLERK 1100 MILLER CLERK 1300 DOE CLERK 15 rows selected. La opción "distinct" selecciona únicamente las diferentes ocurrencias que existen en las tuplas de una columna, o conjunto de ellas. La opción "*" selecciona todas las columnas de la tabla especificada. Si especificamos únicamente una columna de la tabla, deberemos incluir su nombre.

3
Podemos asignarle un alias, es decir, un encabezamiento de la columna en la salida producida, que describa el contenido de las tuplas de la columna que se va a mostrar. Para poder incluir un alias, se escribe dicho alias después del nombre de la columna, sin coma. Si el alias posee espacios entre sus caracteres deberemos usar las comillas dobles para delimitar dicho alias. También se pede incluir opcionalmente la palabra clave "AS" para indicar que se debe renombrar la columna con la palabra que se incluye después. Existen operadores que permiten realizar cambios sobre los datos de salida, estos operadores son:
 || : operador de concatenación, permite concatenar una cadena entre comillas simples a la cadena de salida del mandato "select".
 +: suma, permite sumar una cantidad determinada al dato de salida del mandato "select".
 -: resta, permite restar una cantidad determinada al dato de salida del mandato "select".
 *: multiplicación, permite multiplicar por una cantidad determinada el dato de salida del mandato "select".
 /: división, permite dividir por una cantidad determinada el dato de salida del mandato "select".
TEMA 2: Restricción y Ordenación de los datos recuperados
Vamos a incluir en la sintaxis del mandato "select" básico, una nueva sentencia, "WHERE", que nos va ha permitir restringir la salida del mandato según las condiciones indicadas en esta sentencia. Así, la sintaxis queda como: SELECT [DISTINCT] {*, columna [alias],...} FROM nombre_tabla [WHERE condition(s)]; Como se puede observar, la inclusión de esta cláusula es opcional. Un mandato "select" con una cláusula "where" mostrará únicamente los datos que cumplan la condición especificada en ella. La condición se expresa mediante una serie de operadores que son:
 = (igual), > (mayor que), >= (mayor o igual que), < (menor que), <= (menor o igual que), <> (distinto de)
 "between .... and ...." (entre los valores .... y ....)
 "in (..., ..., ......)" (se encuentra en la lista dada entre paréntesis y cuyos valores están separados por comas)
 "like" (igual a, pero para cadenas de caracteres)
 "is null" (para cadenas o caracteres nulos)

4
Se pueden concatenar condiciones, de manera que la salida será según el operador:
 "condición AND condición" (mostrará los datos que cumplan las condiciones que se encuentran antes y después de este operador).
 "condición OR condición" (mostrará los datos que cumpla la condición que se encuentran antes ó después de este operador).
 "NOT condición" (mostrará los datos que no cumplan la condición que se encuentra después de este operador).
Para ordenar los datos que recuperamos mediante el mandato "select", se usa la cláusula "ORDER BY nombre_columna" así tenemos ahora: SELECT [DISTINCT] {*, columna [alias],...} FROM nombre_tabla [WHERE condition(s)] [ORDER BY column_name [{DESC, ASC}]; Se puede observar que esta cláusula también es opcional. La ordenación es por defecto ascendente, es decir , de menor a mayor, excepto en el caso de que se incluya la palabra reservada "DESC". Esta palabra reservada, hay que incluirla para cada una de las columnas que se incluyen dentro de la sentencia 'ORDER BY...'. Por ejemplo, la consulta: SELECT ename, sal, comm FROM emp WHERE comm IS NOT NULL ORDER BY sal,comm DESC; Ofrece la salida: ENAME SAL COMM ---------- --------- --------- MARTIN 1250 1400 WARD 1250 500 TURNER 1500 0 ALLEN 1600 300 Donde se puede observar que se ha ordenado de mayor a menor la columna de las comisiones ('comm') pero de menor a mayor en el campo del salario, tomando además este como el campo de ordenación principal. Así, el salario ('sal') esta ordenado en orden ascendente por defecto. Para poder ordenar en orden descendente de salario y comisiones la consulta correcta es:

5
SELECT ename,sal,comm FROM emp WHERE comm IS NOT NULL ORDER BY sal DESC,comm DESC; que ofrece la salida: ENAME SAL COMM ---------- --------- --------- ALLEN 1600 300 TURNER 1500 0 MARTIN 1250 1400 WARD 1250 500
TEMA 3: Funciones sobre cadenas de caracteres y tipos de datos especiales.
Funciones para cadenas
Para la manipulación de cadenas de caracteres existen funciones como:
 LOWER({columna,expresion}): Pasa toda la cadena indicada en el nombre de columna, o en expresión entre comillas simples a letras minúsculas.
 UPPER({columna,expresion}): Pasa toda la cadena indicada en el nombre de columna, o en expresión entre comillas simples a letras mayúsculas.
 INITCAP({columna,expresion}): Pasa toda la cadena indicada en el nombre de columna, o en expresión entre comillas simples a letras donde la primera letra esta en mayúscula y el resto en minúsculas.
 CONCAT(cadena1,cadena2): Devuelve una cadena concatenación de 'cadena1' y 'cadena2'.
 SUBSTR(cadena,n,m,.....): Devuelve los caracteres de la cadena desde el n, hasta el carácter número m.
 LENGTH(cadena): Devuelve un entero con el número de caracteres de la cadena pasada como parámetro.
 LPAD(columna,numero_caracteres,'caracter') ofrece a la salida un cadena de longitud 'numero_caracteres' que contiene a caracteres 'caracter' a la izquierda y el contenido de la columna indicada en 'columna', rellenando dicha cadena, con los caracteres especificados hasta alcanzar el tamaño indicado.
Estas funciones nos permiten consultas como: SELECT ename, job, hiredate

6
FROM emp WHERE LOWER(ename)='blake'; Donde el nombre que encontramos en la tabla, puede estar escrito de cualquier manera, pero se pasa a letras minúsculas para ser comparado con el nombre 'blake'.
Funciones numéricas
También existen funciones numéricas tales como:
 ROUND({columna,expresión,numero}): que obtiene el redondeo de la cifra pasada como parámetro a un número entero.
 TRUNC({columna,expresion},n): que obtiene el redondeo de la cifra real pasada como primer parámetro a un número con tantos decimales como se le indique en el segundo parámetro 'n'.
 MOD(m,n): Que obtiene el resto de la división entera entre 'm' y 'n'.
Donde la utilidad de estas es similar a la que se muestra en el conjunto de funciones anterior, pero además se puede utilizar (como las anteriores también) en consultas como la siguiente: SELECT empno,ename,sal,round (sal*1.15) "New Salary" FROM emp; Que ofrece la salida siguiente: EMPNO ENAME SAL New Salary --------- ---------- --------- ---------- 7839 KING 5000 5750 7698 BLAKE 2850 3278 7782 CLARK 2450 2818 7566 JONES 2975 3421 7654 MARTIN 1250 1438 7499 ALLEN 1600 1840 7844 TURNER 1500 1725 7900 JAMES 950 1093 7521 WARD 1250 1438 7902 FORD 3000 3450 7369 SMITH 800 920 7788 SCOTT 3000 3450 7876 ADAMS 1100 1265 7934 MILLER 1300 1495 8000 DOE 15 rows selected.

7
Donde en la columna 'New Salary', se ofrece el redondeo de la cifra obtenida al multiplicar el salario del trabajador por 1.15.
Funciones para fechas
También existen funciones específicas para el tipo de dato 'fecha', de Oracle que son:
 MONTHS_BETWEEN(date1,date2): Devuelve los meses que hay entre dos fechas dadas como 'date1' y 'date2'.
 ADD_MONTHS(date,n): Devuelve una fecha con 'n' meses añadidos a la fecha pasada como primer parámetro.
 NEXT_DAY(date,'char'): Permite conocer la fecha (valor devuelto) del día indicado en 'char' siguiente a la fecha pasada como primer parámetro. Por ejemplo podemos conocer la fecha del siguiente lunes a partir de una fecha determinada.
 LAST_DAY(date): Devuelve el último día del mes.
Para realizar conversiones explicitas entre tipos de datos en relación al tipo de dato 'fecha', se usan funciones como:
 TO_CHAR(number/date,[fmt]): Devuelve una cadena obtenida a partir de una fecha o un número.
 TO_DATE('char',[fmt]): Devuelve una fecha creada a partir de una cadena pasada como parámetro.
 TO_NUMBER(char): pasa a número la cadena pasada como parámetro.
En este último grupo de funciones, encontramos un parámetro, que es el formato de fecha. Este formato está formado por una serie de caracteres dados, que permiten al SGBD determinar el formato en el que se ha pasado la fecha. El formato por defecto es: DD-Month-YY, es decir, una fecha con este formato podría ser: '12-May-03'. Estos caracteres especiales son:
 YYYY: Número del año completo y en número entero.
 YY: año, en dos cifras (2003-->03)
 Year: Forma escrita del año (la primera en mayúscula y las siguientes en minúscula).
 MM: Mes, en cifras numéricas
 Month: Mes escrito en letras (la primera en mayúscula y las siguientes en minúscula).
 DD: Cifra numérica del año.
 Day: Día escrito en letras (la primera en mayúscula y las siguientes en minúscula).

8
Como ejemplo, podemos ver los empleados dados de alta entre el 20 de febrero del 81, y el 1 de mayo del mismo año. SELECT ename,hiredate FROM emp WHERE hiredate BETWEEN to_date('20-February-81','DD-Month-YY') AND to_date('01-May-81','DD-Month-YY');
Funciones especiales
Existen otras funciones especiales, no asociadas a ningún tipo de dato en especial, entre las que podemos encontrar:
 NVL(columna,sustitución): Permite cambiar cualquier valor nulo por el dato que interese. Detecta los valores nulos en la columna pasada como primer parámetro y los sustituye por el dato pasado en el segundo parámetro. Por ejemplo, en esta consulta, se muestra con un cero a los empleados que no ganan comisiones:
SELECT ename, NVL(comm,0) "Commisions" FROM emp; Esta función es especialmente interesante ya que cualquier operación con un dato nulo da como resultado otro dato nulo, lo cual puede no interesarnos, en casos como el de calcular el salario total de todos los empleados, ya que aquellos que no cobran comisión, tienen un valor NULL en este campo (comm=NULL), y sumado al salario, daría el valor nulo, con lo que la salida no sería correcta.
 DECODE Function: Esta función es similar a un "case" de C, o un "Según" en pseudocódigo, permite especificar los valores a mostrar, según una columna dada, o el valor de una expresión. Por ejemplo:
SELECT job, sal, DECODE (job, 'ANALYST', sal*1.1, 'CLERK', sal*1.5, 'MANAGER',sal*1.20, sal) "Revised Salary" FROM emp; De esta manera adecuamos la subida de salario en función del trabajo.

9
TEMA 4: Productos Cartesianos.
En este tema se aprende a obtener datos de múltiples tablas dentro de la base de datos que tenemos, así en nuestro caso, tenemos las tablas 'emp' y 'dept' definidas al comienzo del presente documento. Para ello es necesario que ambas tablas posean una clave foránea, que es un campo que permite relacionar los datos que ambas contienen, así, para conocer la localización del departamento donde trabaja un empleado, necesitaremos ambas tablas. Este tipo de consultas se realiza teniendo en cuenta los siguientes puntos:
 Incluir las tablas que vamos a necesitar en la cláusula 'from' que en nuestro caso serán, como ya se ha dicho antes, las tablas 'emp' y 'dept'.
 Es necesario, en algunos casos, definir a que tabla pertenece la columna que deseamos recuperar con nuestra consulta. Así, en caso de que una columna este en ambas tablas, se deberá hacer mención a esas columnas mediante el nombre de la tabla, un punto, y el nombre de la columna.
 También, debemos evitar que se produzca un producto cartesiano. Siempre que utilicemos dos o más tablas en una consulta, deberemos "emparejar" las tuplas de las tablas, de manera que el SGBD de Oracle pueda mostrarnos la información correcta. si no se realiza esta acción, emparejará cada tupla de una tabla con todas las de la otra u otras, es decir, realiza un producto cartesiano de las tablas que intervienen en la consulta.
A continuación veremos un ejemplo de lo que se acaba de explicar. Supongamos que queremos recuperar los nombres de los trabajadores, y el departamento donde trabajan, así como la localización de este departamento. Podríamos realizar la siguiente consulta, sin tener en cuenta el producto cartesiano, que provocará que la salida sea incorrecta: SELECT ename, deptno, loc FROM emp, dept; Esta consulta ofrece a la salida lo siguiente: SELECT ename, deptno, loc * ERROR at line 1: ORA-00918: column ambiguously defined

10
Debido a que la columna 'deptno', esta definida tanto en la tabla 'emp' como en la tabla 'dept', así es que nos informa de que la columna esta definida ambiguamente. Si subsanamos ese error, queda la consulta: SELECT ename, dept.deptno, loc FROM emp, dept; Ahora se nos ofrece a la salida la siguiente lista de tuplas: ENAME DEPTNO LOC ---------- --------- ------- KING 10 NEW YOR BLAKE 10 NEW YOR CLARK 10 NEW YOR JONES 10 NEW YOR MARTIN 10 NEW YOR ALLEN 10 NEW YOR TURNER 10 NEW YOR JAMES 10 NEW YOR WARD 10 NEW YOR FORD 10 NEW YOR SMITH 10 NEW YOR SCOTT 10 NEW YOR ADAMS 10 NEW YOR MILLER 10 NEW YOR DOE 10 NEW YOR KING 20 DALLAS BLAKE 20 DALLAS CLARK 20 DALLAS JONES 20 DALLAS MARTIN 20 DALLAS ALLEN 20 DALLAS ............................................. ............................................. FORD 40 BOSTON SMITH 40 BOSTON SCOTT 40 BOSTON ADAMS 40 BOSTON MILLER 40 BOSTON DOE 40 BOSTON 60 rows selected.
Tal y como podemos comprobar, esta no es la salida que deseamos obtener, ya que tenemos 60 filas, y en realidad en nuestra empresa tan solo hay 15 trabajadores, luego algo ha pasado. Efectivamente se ha producido un producto cartesiano entre las tuplas de las tablas 'emp' y 'dept'. Para evitar esto, debemos emparejar cada empleado con la localización del departamento en que trabaja, ya que antes se han emparejado todos los

11
empleados con todos los departamentos existentes en nuestra empresa (producto cartesiano). Así, la consulta correcta que nos ofrece los datos requeridos es: SELECT ename, dept.deptno , loc FROM emp, dept WHERE emp.deptno=dept.deptno; Consulta que ofrece a la salida los datos correctos sobre la localizacion del departamento, donde trabajan todos los empleados: ENAME DEPTNO LOC ---------- --------- ------------- KING 10 NEW YORK BLAKE 30 CHICAGO CLARK 10 NEW YORK JONES 20 DALLAS MARTIN 30 CHICAGO ALLEN 30 CHICAGO TURNER 30 CHICAGO JAMES 30 CHICAGO WARD 30 CHICAGO FORD 20 DALLAS SMITH 20 DALLAS SCOTT 20 DALLAS ADAMS 20 DALLAS MILLER 10 NEW YORK DOE 10 NEW YORK 15 rows selected. Dependiendo del tipo de relación a que estén sujetas las tablas, se pueden definir varios tipos de emparejamiento dentro de este tipo de consultas que veremos mediante ejemplos, así, tenemos:
 Equijoins (igualdad): Cuando la relación es de uno a uno, es el caso anterior. Un ejemplo es la consulta realizada anteriormente.
 Non-equijoins (no igualdad): son relaciones que no son de igualdad, como ejemplo utilizaremos la tabla 'salgrade' en la siguiente consulta:
SELECT ename, sal, grade FROM emp, salgrade WHERE sal BETWEEN losal AND hisal; que ofrece la siguiente salida: ENAME SAL GRADE ---------- --------- --------- JAMES 950 1

12
SMITH 800 1 ADAMS 1100 1 MARTIN 1250 2 WARD 1250 2 MILLER 1300 2 ALLEN 1600 3 TURNER 1500 3 BLAKE 2850 4 ......... 14 rows selected.
 Outer-joins (filas que no tienen ningún valor): Si existen filas que no tiene ningún valor asociado, ejemplo:
SELECT e.ename, d.deptno, d.dname FROM emp e, dept d WHERE e.deptno(+)=d.deptno ORDER BY e.deptno; que ofrece al siguiente salida: ENAME DEPTNO DNAME ---------- --------- -------------- KING 10 ACCOUNTING CLARK 10 ACCOUNTING DOE 10 ACCOUNTING MILLER 10 ACCOUNTING JONES 20 RESEARCH SCOTT 20 RESEARCH ADAMS 20 RESEARCH SMITH 20 RESEARCH FORD 20 RESEARCH BLAKE 30 SALES MARTIN 30 SALES ALLEN 30 SALES TURNER 30 SALES JAMES 30 SALES WARD 30 SALES 40 OPERATIONS 16 rows selected. Donde se puede observar que se coloca el símbolo (+) para indicar que la salida puede ser nula en los campos que poseen ese símbolo, y así, mostramos todos los departamentos existentes, aunque estos no tengan asignado ningún trabajador.

13
 Self-joins (para datos almacenados en la misma tabla): este tipo de consultas, se realizan entre datos de la misma tabla. Como se ha podido observar, se pueden asignar alias a las tablas, de manera que no haga falta que se escriba el nombre completo de la tabla cuando queremos distinguir dos campos de igual nombre, pero que pertenecen a tablas distintas. esto podemos usarlo para realizar consultas como la siguiente:
SELECT worker.ename||' works for '||manager.ename FROM emp worker, emp manager WHERE worker.mgr=manager.empno; Consulta que ofrece a la salida, el nombre de todos los empleados, y el jefe del cual depende: WORKER.ENAME||'WORKSFOR'||MANAG ------------------------------- BLAKE works for KING CLARK works for KING JONES works for KING MARTIN works for BLAKE ALLEN works for BLAKE TURNER works for BLAKE JAMES works for BLAKE WARD works for BLAKE FORD works for JONES SMITH works for FORD SCOTT works for JONES ADAMS works for SCOTT MILLER works for CLARK DOE works for BLAKE 14 rows selected.
TEMA 5: Funciones de grupo. Agrupar datos.
Existen funciones no especificadas en el tema 3 que permiten calcular valores como medias, valores máximos etc. Estas funciones son entre otras:
 MAX(columna): ofrece a la salida el valor máximo encontrado en la columna especificada en el parámetro.

14
 MIN(columna): ofrece a la salida el valor mínimo encontrado en la columna especificada en el parámetro.
 AVG(columna): ofrece a la salida el valor de la media aritmética en la columna especificada en el parámetro.
 SUM(columna): Que ofrece a la salida, la suma de todas las ocurrencias encontradas en la columna que se pasa como parámetro a la función.
 COUNT(columna): Cuenta el nº de filas en una columna de la tabla.
 STDDEV(columna): Obtiene la desviación típica en los valore de una columna de la tabla.
Así, podemos crear consultas tales como la siguiente: SELECT max(sal), min(sal), avg(sal), sum(sal) FROM emp WHERE job like 'sales%'; Que ofrece a la salida una sola fila que contendrá los valores especificados en las funciones definidas anteriormente. Dentro de estas funciones, es de especial importancia, la función COUNT, ya que esta puede tener en cuenta valores nulos en el momento de realizar la cuenta, o no. Así, podemos ver que en la siguiente consulta, se realiza una cuenta de todas las ocurrencias de las columnas, sin importar si estas contienen valores nulos o no: SELECT count(*) FROM emp WHERE deptno=30; Esta consulta ofrece a la salida una sola fila (y columna) con el valor de todas las ocurrencias de la tabla en las que se encuentre un valor en la columna 'deptno' igual a 30. Sin embargo, en el siguiente caso, en el que se especifica un nombre de columna, si se tienen en cuenta aquellos valores que poseen un valor nulo: SELECT count(comm) FROM emp WHERE deptno=30;
Así, se ofrece a la salida de nuevo una sola fila con el número de ocurrencias que poseen en la columna de las comisiones un valor distinto de NULL. Esta función, permite además la inclusión de la palabra reservada DISTINCT para contar las ocurrencias de valores distintos como

15
se muestra en la siguiente consulta que muestra el número de managers que existen en la empresa: SELECT count(distinct mgr) FROM emp; El resto de funciones no tienen en cuenta el valor NULL, es decir, cualquier otra función de las especificadas anteriormente (sum, avg, max, min...) no tienen en cuenta el valor nulo a la hora de realizar los cálculos, debido a que tampoco aceptan el '*' como un nombre de columna válido. Si queremos que estas funciones tengan en cuenta los valores nulos, tendremos que valernos de la función NVL, como se muestra en el siguiente ejemplo: SELECT avg(nvl(comm,0)) FROM emp; En este caso, la media tendrá en cuenta todos los valores nulos, que serán sustituidos por un cero. Estas funciones son llamadas "de grupo" debido a que permiten la inclusión de una nueva cláusula que permite presentar la información por grupos de datos que tengan características distintivas. Así podremos agrupar la salida de una consulta que calcule la media del salario para los distintos departamentos que existen en nuestra empresa. Esto es posible mediante la cláusula GROUP BY que se añade a la sintaxis original de la orden SELECT quedando como se muestra a continuación en caso de que utilicemos funciones de grupo: SELECT {columna [alias],funcion_de_grupo(columna)} FROM nombre_tabla [WHERE condition(s)] [GROUP BY columna]; Como ejemplo, se mostrará la siguiente consulta: SELECT deptno, avg(sal) FROM emp GROUP BY deptno; Que nos mostrará a la salida, la media del salario de cada uno de los diferentes departamentos que podemos encontrar en nuestra empresa. DEPTNO AVG(SAL) --------- --------- 10 2916.6667

16
20 2175 30 1566.6667 Tambien podemos agrupar por más de una columna, como se muestra en la siguiente consulta: SELECT deptno, avg(sal) FROM emp GROUP BY deptno, job; Que ofrece la siguiente salida: DEPTNO AVG(SAL) --------- --------- 10 1300 10 2450 10 5000 20 3000 20 950 20 2975 30 950 30 2850 30 1400 9 rows selected. Consulta que no tiene mucho sentido si no se muestra el trabajo por el cual se agrupan los datos, pero se ha realizado de esta manera para mostrar la posibilidad de hacerlo. En cambio hay que destacar que no se puede realizar esta consulta sin incluir la cláusula GROUP BY, ya que Oracle intentará mostrar la media del salario, para todas las tuplas (ocurrencias) de la tabla, y calcular la media para una sola ocurrencia, lo cual carece de sentido. Es decir, si incluimos una función de grupo en la lista de columnas y un(os) nombre(s) de columna simple, debemos agrupar por ese(os) nombre(s) de columna ya que esta cláusula, debe poseer como campos de agrupamiento todas las columnas que no estén incluidas en funciones de grupo. Así, la siguiente consulta sería incorrecta: SELECT dept.dname, dept.loc, count(empno), avg(sal) FROM emp, dept WHERE emp.deptno=dept.deptno GROUP BY dept.dname; Y nos ofrecería un mensaje de error a la salida, a no ser que agrupásemos por nombre de departamento y por localización, en cuyo caso, ofrecería el número de trabajadores que hay en cada departamento así:

17
SELECT dept.dname, dept.loc, count(empno), avg(sal) FROM emp, dept WHERE emp.deptno=dept.deptno GROUP BY dept.dname; Consulta que ofrecería a la salida lo siguiente: DNAME LOC COUNT(EMPNO) AVG(SAL) -------------- ------------- ------------ --------- ACCOUNTING NEW YORK 4 2916.6667 RESEARCH DALLAS 5 2175 SALES CHICAGO 6 1566.6667 Otra de las restricciones a tener en cuenta cuando utilizamos funciones de grupo, es que no podemos incluir funciones de grupo en la cláusula WHERE, es decir, no están permitidas consultas como la siguiente: SELECT deptno, count(ename) FROM emp WHERE avg(sal)>2000 GROUP BY deptno; Para ello se habilita una nueva cláusula, HAVING, que si permite la inclusión de este tipo de funciones en las agrupaciones de datos. Esta cláusula siempre se añade al final de la consulta excepto en el caso de que debamos incluir una cláusula ORDER BY, y se puede utilizar en consultas como la siguiente: SELECT deptno, count(ename),avg(sal) FROM emp WHERE deptno in (10,20) GROUP BY deptno HAVING avg(sal)>2200; Esta consulta muestra el numero de empleados en los departamentos que tienen una media de salario mayor a 2200$ y tan solo para los departamentos 10 y 20,(la media del salario en el departamento 20 es 2175) luego la salida será: DEPTNO COUNT(ENAME) AVG(SAL) --------- ------------ --------- 10 4 2916.6667
En el siguiente ejemplo, se muestra el numero de manager, y el salario del empleado peor pagado (salario mínimo) para aquellos

18
empleados que tengan manager (su manager no sea un valor NULL) y excluyendo aquellos grupos cuyo mínimo salario sea menor de 1000$ y en orden descendente de salario mínimo: SELECT mgr, min(sal) FROM emp WHERE mgr is not null GROUP BY mgr HAVING min(sal)>1000 ORDER BY min(sal) desc; Así la salida es: MGR MIN(SAL) --------- --------- 7566 3000 7839 2450 7782 1300 7788 1100
TEMA 6: Subconsultas
Son consultas dentro de la cláusula WHERE de una consulta. Este tipo de consultas debe devolver un solo valor en cada fila, ya que se utilizan para la comparación dentro de la cláusula antes indicada. Como ejemplo, podríamos buscar el nombre y el número del empleado que tenga el salario mínimo. Así, deberemos incluir en la cláusula WHERE una comparación con el salario del empleado que posea el salario mínimo, lo cual se hace de la siguiente manera. SELECT ename, empno FROM emp WHERE sal =(SELECT min(sal) FROM emp); Es de destacar que dentro de la subconsulta no podemos incluir ninguna cláusula ORDER BY. Si se puede usar sin embargo la cláusula WHERE para restringir al salida a una sola fila. Por ejemplo podemos buscar aquellos empleados que posean un salario mayor que el salario que gana el empleado número 7566 y que tengan el mismo trabajo que el empleado número 7369 mediante la siguiente consulta: SELECT ename, job FROM emp

19
WHERE sal>(SELECT sal FROM emp WHERE empno=7566) AND job like (SELECT job FROM emp WHERE empno = 7369); De esta manera mediante dos subconsultas podemos hallar los datos pedidos. También se puede incluir la cláusula HAVING en una subconsulta, si utilizamos funciones de grupo de manera que restrinjan la salida a una sola fila. Existen casos en los que podemos realizar consultas que devuelvan más de una fila. En estos casos el criterio de comparación debe ser mediante uno de los siguientes operadores:
 IN: Para que los valores devueltos coincida con uno de los valores de la lista. Es equivalente a '=ANY'.
 ANY: Se utiliza siempre detrás de algún operador de comparación, tal como <,>,<=,>=,<>,..... e indica que debe ser comparado con alguno de los valores de la lista.
 ALL: Este operador también va precedido de un operador de comparación (<,>,<=,>=,.....), pero esta vez indica que la comparación debe cumplirse para todos los valores que devuelva la subconsulta.
Como ejemplo de lo expuesto anteriormente, vamos a obtener el nombre y el numero de los empleados que trabajan en un departamento que tenga algún empleado cuyo nombre contenga una 'T'. SELECT ename, empno FROM emp WHERE deptno IN (SELECT deptno FROM emp WHERE lower(ename) like lower( '%T%')); También, como ejemplo vamos a hallar el nombre de los empleados cuyo salario sea menos que alguno de los empleados cuyo trabajo sea CLERK así: SELECT ename, empno FROM emp WHERE sal <ANY (SELECT sal FROM emp WHERE job like 'CLERK');

20
Por último, hallaremos los empleados cuyo salario sea mayor que el de todos los empleados (mayor que el mayor de todos los salarios) de lso empleados cuyo trabajo sea CLERK de la siguiente manera: SELECT ename, empno FROM emp WHERE sal >ALL (SELECT sal FROM emp WHERE job like 'CLERK');
TEMA 7:Subconsultas que devuelven múltiples columnas
Este tipo de consultas, son similares a las anteriores, pero en este caso se devuelven varias columnas, no solo una. La forma de hacerlo, normalmente es incluyendo entre paréntesis los dos campos o columnas con las que se pretende comparar la salida de la subconsulta, ya que en el caso de necesitar una consulta de este tipo, podremos encontrarnos con varias posibilidades. La primera de ellas es el caso mencionado en el que necesitamos que coincidan ambas columnas (matches both) que se llama 'Pairwise', y el segundo caso es en el que necesitemos que coincida alguno de los campos o columnas con la restricción a imponer, llamada 'Non- pairwise'. Vamos a citar dos ejemplos, uno para cada tipo. En primer lugar, hallaremos el nombre, el numero de departamento y la comisión de aquellos empleados cuyo salario y comisión coinciden ambos a la vez con el salario y la comisión de algún empleado del departamento 30: SELECT ename, deptno, comm FROM emp where (sal, nvl(com,-1)) in (SELECT sal, nvl(comm,-1) FROM emp WHERE deptno=30); Este es un ejemplo de Pairwise, en el que las columnas o campos deben compararse por pares, es decir debe coincidir la pareja de valores de salario y comisión de un empleado con la pareja salario y comisión de un empleado del departamento 30. Es de destacar el uso de la función NVL para evitar los valores nulos, ya que cualquier operación entre dos valores nulos da como resultado el valor nulo, luego en la comparación de igualdad entre dos valores nulos, nos daría falso (null=null ->null -falso-). Como ejemplo de Nonpairwise, podemos encontrar una consulta como: SELECT ename, job

21
FROM emp WHERE sal>(SELECT sal FROM emp WHERE empno=7566) AND job like (SELECT job FROM emp WHERE empno = 7369); Anteriormente descrita, y que pretende buscar aquellos empleados que posean un salario mayor que el salario que gana el empleado número 7566 y que tengan el mismo trabajo que el empleado número 7369. Las subconsultas no solo pueden estar en la cláusula WHERE, también podemos tener subconsultas dentro de la cláusula FROM, donde se crea una nueva tabla que contendrá las columnas y las filas que devuelva la consulta realizada. Para ilustrar esto, vamos a realizar una consulta que muestre el número de empleado, el departamento al que pertenece, y la media del salario de dicho departamento. En un principio, podemos pensar que la siguiente consulta obtiene dichos valores: SELECT empno, deptno, avg(sal) FOM emp GROUP BY empno, deptno; Pero esto es incorrecto, ya que intentará calcular la media para un grupo por cada número de empleado (empno), y la salida será incorrecta. Sin embargo, podemos calcular la media para cada departamento, incluirla en una tabla, y asociarla con cada empleado. Así, deberemos crear la siguiente consulta: SELECT empno, deptno, avg.media FROM emp, (SELECT deptno, avg(sal) media FROM emp GROUP BY deptno) avg WHERE emp.deptno=avg.deptno; Donde como se puede comprobar, la subconsulta de la cláusula FROM, crea una tabla llamada 'avg', que contiene la media del salario de cada departamento.
TEMA 8: Operadores de conjunto
En este tema se analizan los operadores de conjunto 'intersect', 'union', 'union all' y 'minus'. Estos operadores, nos permiten tomar las consultas por conjuntos de tuplas, que tienen varias columnas. Así, podemos hallar la intersección, la resta, o la union de los elementos de cada conjunto. La descripción de cada operación, es la siguiente:

22
 Intersect: Devuelve los elementos comunes a dos conjuntos, es decir las tuplas que coinciden en dos consultas distintas. Hay que tener en cuenta, que para que pueda haber una intersección, ambas consultas deben seleccionar las mismas columnas.
 Union / Union all: Estos operadores actúan de forma muy similar, ambos devuelven la salida de una consulta más la salida de otra. La diferencia es que el primero, no incluye elementos repetidos, sin embargo, 'Union all' si incluye estos elementos repetidos.
 Minus: Este operador, devuelve las tuplas de la primera consulta menos las tuplas de la segunda consulta.
Como ejemplo de consultas, podemos mostrar todos los empleados que han trabajado en la empresa, ayudándonos de la tabla 'emp_history' que contiene el historial de todos los trabajadores que hay y han habido en la empresa, así, tendremos: SELECT ename,job, deptno FROM emp UNION SELECT name,title,deptid FROM emp_history; Otro ejemplo del uso de este tipo de operadores nos permite mostrar aquellos empleados que están en ambas tablas a la vez de la siguiente manera: SELECT ename,job, deptno FROM emp INTERSECT SELECT name,title,deptid FROM emp_history; También podemos encontrar aquellos que tendríamos que introducir en la tabla de la siguiente manera: SELECT ename,job, deptno FROM emp MINUS SELECT name,title,deptid FROM emp_history; Así, para realizar este tipo de consultas, tenemos que tener en cuenta los siguientes puntos:

23
 Las expresiones de las consultas tienen que coincidir en cantidad y tipo de los datos que se van a mostrar (ej: ename -> name).
 Automáticamente en todos los operadores de conjuntos las filas repetidas son borradas (en la salida y excepto en el operador 'union all')
 Los encabezamientos de las filas que se ofrecen a la salida son los de la primera consulta realizada.
TEMA 9: Manipulación de datos
El lenguaje de manipulación de datos es el que nos permite tanto la inserción como el borrado de los datos en las tablas de que dispone nuestra base de datos. Asi, se definen varias ordenes que permiten realizar este tipo de acciones.
Añadir una nueva fila en la tabla:
INSERT INTO tabla[(columa[, columna,....])] VALUES (valor[, valor, ......]); [consulta] Si se omiten los campos después del nombre de la tabla, es que deseamos introducir una fila con todos los campos que contiene la tabla, y si lo que añadimos es una consulta, se introducen los datos devueltos por esa consulta. Así, como ejemplo, podemos incluir una fila en la tabla 'dept' que contenga el número de departamento 50, llamado 'development' y localizado en 'detroit', así deberemos introducir la siguiente orden de entrada de datos: INSERT INTO dept(deptno,dname,loc) VALUES (50,'DEVELOPMENT','DETROIT'); Se pueden crear macros para la introducción de los datos, y usar asi variables para la introducción de estos datos. Para ello, utilizamos el comando ACCEPT, que nos permite declarar una variable de entorno con un nombre cualquiera: ACCEPT nombre_variable PROMPT 'mensaje_introducción';

24
Esta orden, nos permite sacar por pantalla el mensaje 'mensaje_introducción' y despues quedar a la espera de la introducción del valor que se asignará a la variable nombre_variable. Asi, un ejemplo de macro para realizar la introducción de la fila que se ha introducido antes es: ACCEPT num_dept PROMPT 'introduzca el número de depto.: '; ACCEPT nom_dept PROMPT 'introduzca el nombre de depto.: '; ACCEPT loc_dept PROMPT 'introduzca la localización de depto.: '; INSERT INTO dept(deptno,dname,loc) VALUES (&num_dept,'nom_dept','loc_dept'); Esto provocará la siguiente salida por pantalla: SQL> @a:/p2ej.sql introduzca el número de depto.: 50 introduzca el nombre de depto.: DEVELOPMENT introduzca localizacion de depto.: DETROIT old 2: VALUES (&num_dept,'nom_dept','locdept') new 2: VALUES (50,'nom_dept','locdept') 1 row created. SQL> Habiendo guardado previamente esta macro en el archivo p2ej.sql en la ruta especificada. Es de destacar, que las variables, se deben referenciar mediante el '&' delante del nombre de variable y las cadenas además entre comillas simples.
Modificacion de datos en la tabla:
Para la modificación de datos de la tabla se usa el mandato UPDATE de la siguiente manera: UPDATE nombre_tabla SET columna=valor [, columna2=valor2, .....] [WHERE condicion]
En este caso, substituimos el valor de la columna especificada por el valor introducido. La sentencia WHERE, es opcional, y si se omite, se modificarán todos los valores de la(s) columna(s) especificada(s) pero si se especifica, la modificación tendrá lugar tan solo en la fila que se seleccione según la condición. También es posible especificar una macro que realice

25
esta acción, de la misma manera en la que se realizó en la sentencia de manipulación anterior.
Eliminación de datos en la tabla:
Para la eliminación de datos de una tabla de nuestra base de datos, se utiliza el comando DELETE. La sintaxis de dicho comando es la siguiente: DELETE [FROM] nombre_tabla [WHERE condición]; Este comando posee la posibilidad de borrar una sola fila de la tabla, añadiendo las opciones FROM, y WHERE, ya que se eliminaran las filas de la tabla que cumplan la condición especificada en la sentencia WHERE, pero si estas opciones no se incluyen, se vacía la tabla al completo. Existen una serie de ordenes, que nos permiten una gran seguridad dentro de las bases de datos creadas con Oracle y que son los comandos commit, savepoint y rollback:
 COMMIT: este comando, verifica que las modificaciones realizadas se guardan en la base de datos. Así tras realizar cualquier cambio en esta, mediante el DML (Data Modification Languaje) deberemos ejecutar dicho comando.
 SAVEPOINT nombre_savepoint: Permite realizar una copia de seguridad de los datos guardados en las tablas hasta el momento para luego poder recuperarlos. Se puede indicar el nombre (por ejemplo la fecha y hora) del punto de guardado. Mediante otro comando, podemos volver a los datos que teníamos antes de guardar mediante SAVEPOINT.
 ROLLBACK / ROLLBACK TO nombre_savepoint: Permite volver atrás en los cambios realizados en una tabla. cuando ejecutamos este comando, deshacemos los cambios realizados hasta el último savepoint. Si queremos volver atrás hasta un determinado savepoint, deberemos especificar el savepoint hasta el que queremos volver, mediante la segunda opción de este comando.
Como ejemplo citamos: SQL> savepoint update_done; Savepoint created. SQL> rollback to update_done;

26
Rollback complete. SQL>
TEMA 10: Creación de tablas.
Create table
Para la creación de tablas, se utiliza la orden CREATE TABLE, que tiene varias opciones que iremos viendo poco a poco. La sintaxis básica de esta orden es: CREATE TABLE [esquema.]nombre_tabla [(columna tipo_de_dato [default_expr])]; De esta manera, creamos una tabla con el nombre indicado, y las columnas indicadas si se desea. Si no se desea definir las columnas se puede realizar más adelante con el comando ALTER TABLE que veremos más adelante. Los tipos de datos a los que puede pertenecer una columna son entre otros:
1. VARCHAR2(tamaño): texto de tamaño variable.
2. CHAR(tamaño): carárcter de tamaño variable.
3. NUMBER(p,s): número de tamaño fijo, donde 'p' es el tamaño máximo, y 's' el número de bits después de la coma.
4. DATE: tipo de dato fecha.
5. LONG: Cadena de caracteres de longitud variable hasta 2GB.
6. CLOB: Cadena de caracteres de longitud variable hasta 4GB.
7. RAW y LONG RAW: Datos binarios de tamaño pequeño.
8. BLOB: Datos binarios de hasta 4GB.
9. BFILE: Para ficheros externos.
10. BINARY: Para valores binarios (verdadero,falso).
Por ejemplo, podemos citar la orden de creación de la tabla 'dept', que es la siguiente: CREATE TABLE dept (deptno NUMBER(2), dname VARCHAR2(14), loc VARCHAR2(13)); También podemos crear tablas a partir de subconsultas, mediante esta misma orden, pero en este caso, la sintaxis es la siguiente:

27
CREATE TABLE AS subconsulta; Asi se crea una tabla que contiene todas las columnas que devuelva la consulta realizada en esta orden, y con todas las tuplas que devuelva esta orden. Como ejemplo vamos a crear una tabla llamada 'dept30' que contendrá todos los empleados de dicho departamento, y las columnas empno, ename, y sal: CREATE TABLE deptno30 AS SELECT empno, ename, sal FROM emp WHERE deptno=30;
Alter table
Esta orden, nos permite modificar las columnas de una tabla, para añadir o para modificar el tipo de dato de la columna en cuestión. La sintaxis de la sentencia ALTER TABLE es la siguiente: ALTER TABLE nombre_tabla ([ADD (columna tipo_de_dato)], [MODIFY (columna nuevo_tipo_de_dato)]);
Drop table
Esta elimina la estructura de la tabla por completo, y por tanto la borra por completo. La sintaxis de esta sentencia es la siguiente: DROP TABLE nombre_tabla;
Truncate table
Esta orden vacía el contenido de la tabla, es decir borra todas las filas que contiene, pero deja la estructura. La sintaxis es la siguiente: TRUNCATE TABLE nombre_tabla;
Rename table
En este caso la orden cambia el nombre de la tabla por el especificado mediante la siguiente sintáxis:

28
RENAME nombre_tabla_antiguo TO nombre_tabla_nuevo;
Comment on table
En este caso se le añaden comentarios a las tablas, que permiten describir el contenido de las mismas. Esto se realiza con la orden Comment, que tiene la siguiente sintaxis: COMMENT ON TABLE nombre_tabla IS 'comentario de la tabla';
Restricciones de las tablas (constraints)
Existen varias restricciones posibles para las columnas de las bases de datos mantenidas por Oracle, estas son llamadas 'constraints' y permiten cualidades de las columnas de una tabla tales como hacer cumplir reglas a nivel de tablas, o prevenir el borrado de una tabla si hay dependencias con otra tabla. Los tipos de restricciones posibles en Oracle son:
 NOT NULL: Especifica que esa columna no debe contener un valor nulo.
 UNIQUE key: Especifica una columna o combinación de ellas cuyos valores no deben estar repetidos.
 PRIMARY KEY: Especifica que debe ser llave primaria, por lo tanto, esta, no debe contener valores duplicados, ni poseer valores nulos.
 FOREIGN KEY: Establece y hace cumplir una relación foránea entre la columna, y la otra columna referenciada de la tabla.
 CHECK: Especifica una condición que debe ser cierta.
La sintaxis de creación de una constraint en una tabla es la siguiente: CREATE TABLE [esquema.]nombre_tabla [(columna tipo_de_dato [default_expr] [constraint de columna], ........... [constraint de tabla])];

29
Donde el constraint de columna, es una constraint formada por la palabra clave constraint, seguido de un nombre orientativo que entra en la tabla 'user_constraints' (esto es opcional pero recomendable), y después el tipo_constraint, que es uno de los tipos antes definidos (NOT NULL, PRIMARY KEY,.....) de la siguiente manera: [CONSTRAINT constraint_name] tipo_constraint, Las constraints de tabla, no incluyen la constraint NOT NULL, van siempre al final, y el añadir el nombre de la constraint es también opcional. Se forma mediante la palabra reservada CONSTRAINT y el nombre de constraint (opcional), después el tipo de constraint a aplicar (excepto NOT NULL) y entre paréntesis el nombre de la columna a la que se aplica dicha constraint. Hay que tener en cuenta que estos tipos de constraints se ponen siempre después de haber definido todas las columnas de la tabla: [CONSTRAINT constraint_name] tipo_constraint (nombre_columna,...), Así como ejemplo, introduciremos la constraint que posee la tabla dept, que es NOT NULL en la columna 'deptno' de la siguiente manera: CREATE TABLE dept (deptno NUMBER(2) CONSTRAINT dept_nn NOT NULL, dname VARCHAR2(14), loc VARCHAR2(13)); Por otro lado, podemos definir algunas de las constraints de la tabla emp de la siguiente manera: CREATE TABLE emp (empno NUMBER(4), ename VARCHAR2(10), .... deptno NUMBER(7,2) NOT NULL, CONSTRAINT emp_empno_pk PRIMARY KEY (empno) CONSTRAINT emp_deptno_fk FOREIGN KEY (deptno) REFERENCES dept (deptno) CONSTRAINT emp_deptno_ck CHECK

30
(deptno BETWEEN 10 AND 99)); Se puede observar que todas estas son líneas de la creación de una tabla, que por lo tanto pueden añadirse mediante la orden ALTER TABLE, para añadir dichas constraints posteriormente a las tablas. Así podríamos poner también, una vez creada la tabla sin constraints: ALTER TABLE emp ADD CONSTRAINT emp_empno_pk PRIMARY KEY (empno); Para borrar cualquier constraint, se utiliza la orden ALTER TABLE, que actúa de igual manera que anteriormente, pero ahora, deberemos indicar que queremos borrar y la constraint que queremos borrar, mediante el nombre que le hemos asociado. Así, la orden de borrado de esta última constraint 'emp_empno_pk' es: ALTER TABLE emp DROP CONSTRAINT emp_empno_pk; También podemos deshabilitar dicha constraint, en vez de borrarla, mediante la siguiente orden: ALTER TABLE emp DISABLE CONSTRAINT emp_empno_pk;
TEMA 11: Vistas y secuencias. Objetos de la base de datos.
Dentro de los objetos de una base de datos de Oracle, hemos visto tan solo las tablas, pero también existen objetos tales como vistas, secuencias, índices y sinónimos. En este documento nos centraremos tan solo en las tablas, como ya se ha hecho, en las vistas y secuencias.
Vistas
Una vista crea un subconjunto de datos a partir de una tabla. Sirve para tener un acceso más rápido a una determinada tabla, para dar acceso solo de lectura a un usuario de las tablas etc. Existen dos tipos de vistas , simples y compuestas.
Las vistas simples, contienen una sola tabla, y no contiene funciones, ni grupos de datos, así como DML (data modification languaje) a través de

31
la vista. En cambio, las vistas complejas, contienen más de una tabla, y contienen el resto de características antes mencionadas. La orden de creación de una vista es mediante la orden CREATE, vista anteriormente. Así la sintaxis es la siguiente: CREATE [OR REPLACE] [FORCE|NO FORCE] VIEW nombre_vista AS (subconsulta) [WITH CHECK OPTION [CONSTRAINT constraint]] [WITH READ ONLY]; Las opciones dignas de comentario, son:
 OR REPLACE: vuelve a crear la vista, incluso si esta existe o no.
 FORCE | NO FORCE: Crea la vista incluso si las tablas base de la consulta que se realiza existen o no (en el caso de que incluyamos FORCE) o no crea la vista en caso de que no existan dichas tablas (si incluimos la opción NO FORCE).
 WITH CHECK OPTION: Especifica que solo las filas accesibles a la vista, pueden ser insertadas o modificadas.
 WITH READ ONLY: Asegura que ningún tipo de DML puede ser utilizado en esta vista (luego ninguna modificación de los datos puede ser realizada).
Así como ejemplo vamos a crear una vista llamada EMPVU10 que contenga el numero de empleado, el nombre y el trabajo, de todos los empleados que pertenecen al departamento 10. CREATE OR REPLACE VIEW empvu10 AS SELECT empno, ename, job FROM emp WHERE deptno=10; De esta manera creamos una vista con las características antes mencionadas. Para ver el contenido de dichas vistas, utilizamos una orden SELECT en la que el nombre de la tabla será un nombre de vista. También podemos ver la estructura de una vista mediante la orden DESCRIBE. Para ver las vistas que tenemos creadas, existe la tabla user_views, en cuya columna view_name, podemos encontrar todos los nombres de vistas que tengamos creadas. Una vista compuesta puede ser una vista tal como la siguiente: CREATE VIEW dept_sum_vu (name,minsal,avgsal)

32
AS SELECT d.dname, MIN(e.sal), MAX(e.sal), AVG(e.sal) FROM emp e, dept d WHERE e.deptno=d.deptno GROUP BY d.dname; Orden que crea una vista que contendrá un campo (columna) que será el nombre de departamento, otra columna con el salario mínimo del departamento, otra con el salario máximo del departamento y otra con la media del salario del departamento. Se pueden usar operaciones DML en vistas simples. No se pueden borrar filas si contienen funciones de grupo, una cláusula GROUP BY o la palabra clave DISTINCT. Para borrar una vista, se utiliza la orden DROP VIEW nombre_vista.
Secuencias
Una secuencia genera automáticamente números consecutivos. Es un objeto ocultable y típicamente usado para crear valores de llaves primarias. Se crean mediante la orden CREATE con la siguiente sintaxis. CREATE SEQUENCE nombre_secuencia [INCREMENT BY n] [START WITH n] [MAXVALUE n | NOMAXVALUE] [MINVALUE n | NOMINVALUE] [CYCLE | NOCYCLE]; Por la simple traducción de las palabras clave que se usan como opciones de la sentencia de creación, podemos determinar la función de las mismas. Como ejemplo vamos a crear una secuencia llamada dept_deptno usada por la primary key de la tabla dept: CREATE SEQUENCE dept_deptno INCREMENT BY 1 START WITH 91 MAXVALUE 100 NOCACHE NOCYCLE; Para hacer referencia a los valores de una secuencia, deberemos introducir el nombre de la secuencia, seguido de un punto, y después una de las siguientes opciones:
 NEXTVAL: Accede al próximo valor disponible.

33
 CURRVAL: El valor actual en el que se encuentra la secuencia.
Como ejemplo utilizaremos la secuencia para añadir una nueva fila a la tabla dept utilizando la secuencia antes creada. INSERT INTO dept(deptno, dname, loc) VALUES (dept_deptno.NEXTVAL, 'MARKETING','SAN DIEGO'); Para ver el valor actual de la secuencia que deseemos, tan solo deberemos realizar una consulta con la tabla 'DUAL', en la que referenciemos el valor actual de una secuencia, es decir, para consultar el valor actual de la secuencia que acabamos de crear, deberemos introducir la siguiente orden: SELECT dept_deptno.CURRVAL FROM dual; Tambien es posible tanto la modificación de la secuencia, así como el borrado de la misma, mediante las ordenes ALTER SEQUENCE y DROP SEQUENCE.
TEMA 12: Bloques PL/SQL básicos.
Esta lección presenta la estructura básica de un bloque de código PL/SQL. Estos bloques de código son una especie de scripts, que se transfieren por completo al SGBD y son ejecutados por completo, lo cual permite una secuenciación entre las distintas consultas y acciones sobre la base de datos. La estructura básica de un bloque de código SQL consta de las siguientes dos partes principales que comienzan con las siguientes palabras reservadas:
 'DECLARE' (opcional): A Partir de esta se declaran las variables, los cursores, y las excepciones (errores) declaradas por el usuario.
 'BEGIN': Después de esta palabra, comienza la segunda parte y en ella se incluyen los mandatos SQL y PL/SQL.
 'EXCEPTION' (opcional): A partir de esta palabra reservada se incluye la definición de las excepciones del bloque PL/SQL.
 'END;' : Esta es la palabra final después de la cual, no hay más código.

34
Se debe colocar un punto y coma (;) después de cada sentencia SQL o PL/SQL y una barra invertida (/) para poder ejecutar el bloque. Existen varios tipos de bloques PL/SQL, anónimos, procedimientos y funciones. Los bloques anónimos son bloques sin nombre empotrados dentro de una aplicación o emitidos para su ejecución interactivamente. El resto, tanto los procedimientos, como las funciones, son bloques de código PL/SQL que quedan grabados en el servidor de Oracle, pueden ser invocados repetidamente por su nombre y pueden aceptar parámetros. Comencemos describiendo las variables. Estas son utilizadas para guardar datos temporalmente, manipular estos datos etc. Para su manipulación, debemos declararlas, le asignamos un valor, pasamos los valores y vemos los resultados. También se pueden declarar variables globales, lo cual se realiza antes de la palabra reservada DECLARE. Para la declaración de variables se usa la siguiente sintaxis: nombre_variable tipo_de_dato; Y para las variables globales (BIND), se realiza mediante la siguiente sintaxis: VARIABLE nombre_variable tipo_de_dato Este tipo de variables, se declaran fuera del bloque de código PL/SQL, y se pueden referenciar dentro de este poniendo dos puntos antes del nombre de la variable. El operador de asignación de valores a una variable es ':=', poniendo primero el nombre de la variable a la cual queremos asignar el valor, después el símbolo ':=' y después el valor que queremos asignarle, que puede ser el valor de otra variable por ejemplo. Para imprimir por pantalla, siempre hay que declarar variables globales, y estas se referencian dentro del bloque PL/SQL añadiendo dos puntos (:) antes del nombre de la variable, ej: ':v_ejemplo'. El resto de las variables no pueden ser aceptadas como parámetro de la orden 'PRINT' (La orden PRINT, seguida de un nombre de variable y un punto y coma muestra el contenido de la variable por pantalla, y el nombre de la variable que posee dicho valor.).
El uso de las variables esta restringido únicamente por el tipo de datos al que pertenece una determinada variable. Es decir, es importante asignar a una variable, datos del tipo al cual pertenecen, por lo que es útil la utilización de funciones antes comentadas como 'to_char()', para pasar un tipo de dato fecha ('date') a cadena por ejemplo si vamos a asignarlo a una

35
cadena. Por ejemplo, si declaramos la variable 'v_cadena' de tipo varchar2 así: DECLARE v_cadena varchar2(30); ......... Y a continuación escribimos en la parte de código ejecutable: BEGIN v_cadena:='Anderson'||':'||sysdate; ........... Esto daría un error, ya que sysdate, es de tipo 'date', con lo que el bloque no se ejecutaría correctamente. Así, la correcta formulación que deberíamos realizar para esta acción sería: BEGIN v_cadena:='Anderson'||':'||to_char(sysdate); ........... Nótese que se han utilizado comillas simples para delimitar los valores de cadenas constantes, el operador '||' para concatenar cadenas, y un punto y coma al final de la sentencia. Hasta aquí se ha visto lo mas importante que debemos saber sobre las variables, a partir de ahora describiremos las acciones básicas que se pueden realizar con un bloque de código PL/SQL. Los bloques de código se pueden anidar. Es decir podemos incluir un bloque de PL/SQL dentro de otro, pero hay que tener cuidado con el ámbito de las variables que declaramos, es decir, las variables declaradas en el bloque más exterior, se 'ven' dentro de los bloques de código interiores, pero esto no es cierto al contrario, es decir, las variables de los bloques interiores, no pueden referenciarse por los bloques externos. La orden para pedir datos por pantalla se ha explicado en temas anteriores, esta es la orden 'accept' que debe ponerse fuera de los bloques PL/SQL, con la siguiente sintaxis: ACCEPT nombre_variable PROMPT 'mensaje_introducción'; De esta manera se introducen datos en una variable de entorno, que podemos utilizar luego. Para borrar todas las variables de entorno que tengamos creadas, deberemos introducir la orden 'set verify off'. Para referenciarlas, se incluye un '&' antes del nombre de dicha variable.

36
Para la salida de datos por pantalla, se utiliza la orden dbms_output.put_line con la siguiente sintaxis: dbms_output.put_line({'cadena_a_mostrar',variable_de_cadena}); Dentro de los bloques de PL/SQL, podemos escribir diferentes tipos de consultas. El mandato select que podemos introducir dentro de un bloque de código debe incluir después de la lista de columnas a mostrar (SELECT *) la palabra reservada INTO nombre_variable, para introducir los datos dentro de la variable que se especifique. Así la sintaxis de un mandato select básico queda de la siguiente manera: SELECT [DISTINCT] {*, columna [alias],...} INTO {lista_de variables} FROM nombre_tabla [WHERE condition(s)]; Así, podemos deducir que la lista de variables, debe corresponderse con el número y el tipo de las columnas que estemos seleccionando, para que sean asignadas a las variables correctamente. También debemos notar que estos mandatos select, deben devolver tan solo una fila, es decir que debemos incluir una condición que haga que la consulta devuelva una sola fila en el momento de ser ejecutada. Ahora ya estamos preparados para ver el primer ejemplo de bloque PL/SQL mediante el cual obtendremos el número y la localización de el departamento de ventas (sales) de la tabla dept así: DECLARE v_deptno dept.deptno%TYPE; v_loc dept.loc%TYPE; BEGIN select deptno,loc into v_deptno,v_loc from dept where dname='SALES'; dbms_output.put_line(v_deptno); dbms_output.put_line(v_loc); END; / Que ofrece a la salida el siguiente mensaje:

37
SQL> @a:/plsql1.sql 30 CHICAGO PL/SQL procedure successfully completed. SQL> Se debe de destacar que el tipo de dato al cual pertenecen las variables declaradas v_deptno y v_loc, es el tipo de dato de las variables detpno y loc de la tabla dept. Vamos a realizar ahora una inserción de datos en una tabla mediante un bloque PL/SQL para ver más ejemplos: DECLARE v_empno emp.empno%TYPE; BEGIN select empno_secuence.NEXTVAL into v_empno from dual; insert into emp(empno, ename, job, deptno) values (v_empno,'Harding','clerk', 10); END; / Suponiendo que ya tenemos creada la secuencia empno_sequence, que nos devuelve el valor correcto de número de empleado. Es de notar el uso de la variable declarada como valor a introducir en la orden insert. Dentro de las ordenes de un bloque PL/SQL también existen sentencias de control del flujo del programa y dentro de ellas vamos a comenzar con el mandato IF. Este mandato tiene la siguiente sintaxis: IF condición THEN sentencias_1; [ELSIF condición THEN sentencias_2;] [ELSE sentencias_3;] ENDIF;
Siendo el control de flujo el mismo para todos los lenguajes que poseen una sentencia de bifurcación condicional, es decir , se ejecutarán la(s) sentencia(s) 1 en caso de cumplirse las primeras condiciones, o las

38
sentencias 2 en caso de que se cumplan las segundas condiciones, o si no se cumplen ningunas de las condiciones, se ejecutaran las sentencias 3. Así, podemos realizar bloques de código que realicen acciones en función de el cumplimiento de ciertas condiciones. Otro tipo de sentencias de control del flujo de ejecución son los bucles, dentro de los cuales podemos encontrar bucles tales como LOOP, FOR y WHILE. La sintaxis de estos bloques de código es la siguiente: LOOP sentencias: ... EXIT [WHEN condición]; END LOOP; Para la orden FOR tenemos la siguiente sintaxis: FOR contador IN [REVERSE] limite_inferior..limite_superior LOOP sentencias; ... END LOOP; Y para la orden WHILE tenemos la siguiente sintaxis: WHILE condicion LOOP sentencias; ... LOOP;
TEMA 13: Tipos de datos compuestos
Existen dos tipos de datos compuestos que son:
 RECORDS: Son un tipo de datos definido por el usuario, que contiene varias variables en una sola estrucutura. Es similar a un 'struct' de C.
 TABLES: Son un tipo de dato similar a una tabla, o a un array, en el que se introducen datos de un solo tipo y luego podemos acceder a ellos segun un índice.
Así, la sintaxis para definir estos tipos de datos es la siguiente, para los records:

39
TYPE type_name IS RECORD (nombre_variable1 tipo_de_dato, [nombre_variable2 tipo_de_dato,...]); Y para declarar un record de ese tipo se pone: nombre_record type_name; En ese momento ya podemos utilizar el record mediante la inclusión de un punto, seguido del nombre de la variable que deseamos acceder. Para las TABLES, que son parecidas a los arrays, tenemos la siguiente sintaxis: TYPE type_name IS TABLE OF {(tipo_columna),variable%TYPE} [INDEX BY BINARY INTEGER]; Así, tenemos un array al cual podemos acceder mediante un índice que se pone entre paréntesis. También tenemos una serie de métodos asociados a las TABLES, que nos permiten realizar acciones como:
 EXISTS(n): devuelve verdadero si el valor del índice que contenga no el nulo, es decir tiene asignado algún valor.
 COUNT: devuelve el número de elementos que posee la Table
 FIRST and LAST: Devuelve el valor final o el inicial, dependiendo del método utilizado.
 PRIOR(n): Devuelve el elemento anterior al indicado en el índice.
 NEXT(n): Devuelve el siguiente elemento del indicado por el índice.
 EXTEND(n,i): agrega valores 'i', a partir de 'n'.
 TRIM(n): Elimina los 'n' últimos valores.
 DELETE[(n,m)]: Si no lleva índices, vacía la TABLE entera, si lleva un solo índice borra el elemento indicado, y si lleva los dos índices, borra desde el indice 'n' hasta el índice 'm'.
Vamos a ver dos ejemplos de utilización de estos tipos de datos. Para los tipos de datos RECORD, declararemos uno que almacenará el nombre, el trabajo, u el salario, de un nuevo empleado: TYPE emp_record_type IS RECORD (ename VARCHAR2(10),

40
job VARCHAR2(9), sal NUMBER(7,2)); En este momento tendríamos definido el tipo de dato emp_record_type, y ahora crearíamos una instancia de ese tipo de dato llamado emp_record: emp_record emp_record_type; Para el uso de los distintos campos que contiene la variable que acabamos de declarar, podemos acceder por ejemplo al nombre de la siguiente manera: 'emp_record.ename'. Existe un atributo especial, llamado %ROWTYPE que recoge un dato que puede poseer más de un atributo y asignarlo a un tipo record, así, para crear un record con todas las variables necesarias para guardar una fila completa de la tabla dept, deberíamos poner: dept_record dept%ROWTYPE; Para declarar una table, seguiremos la sintaxis antes definida, y crearemos una table para almacenar nombres de empleados contenidos en la tabla emp así: TYPE ename_table_type IS TABLE OF emp.ename%TYPE INDEX BY BINARY_INTEGER; Ya tendríamos creado el tipo de TABLE ename_table_type, que ahora es un tipo de dato más, y ahora necesitamos una instancia, o variable de ese tipo, así: ename_table ename_table_type; Ahora nos referiremos a los distintos elementos de dicha variable así ename_table(1):='Cameron'; O también podremos acceder a alguno de los métodos antes especificados para realizar acciones como la siguiente: IF ename_table.EXISTS(1) THEN INSERT INTO...........

41
TEMA 14: Cursores
Un Cursor es un área de trabajo de SQL. Cuando emitimos una sentencia SQL, el servidor de Oracle abre un área de memoria, en la que el comando es analizado y ejecutado, este área es llamada cursor. Cuando la parte ejecutable de un bloque emite una sentencia SQL, PL/SQL crea un cursor implícito, que tiene el identificador 'SQL'. Oracle cuenta con dos tipos de cursores, los explícitos y los implícitos, los implícitos están definidos por el identificador 'SQL', y posee atributos que entre otros son:
 SQL%ROWCOUNT: cuenta el número de filas que fueron accedidas en la última operación.
 SQL%FOUND: Posee el valor TRUE si el cursor anterior es igual o mayor que uno, es decir, que se pone a valor TRUE si se a accedido a alguna fila.
 SQL%NOTFOUND: Poseerá el valor TRUE en el caso de que el cursor anterior tenga el valor FALSE, es decir este cursor toma el valor TRUE si en la última operación no se accedió a ninguna fila.
 SQL%ISOPEN: Posee siempre el valor FALSO, porque PL/SQL cierra los cursores explícitos inmediatamente después de ser ejecutados.
Como ejemplo de uso de un cursor explícito, expongo el siguiente boque PL/SQL que imprime el número de columnas que han sido borradas: VARIABLE rows_deleted NUMBER DECLARE v_ordid NUMBER:=605; BEGIN DELETE FROM item WHERE ordid=v_ordid; :rows_deleted:=SQL%ROWCOUNT; END; / PRINT rows_deleted Los cursores explícitos sin embargo, son definidos por el usuario, y a la zona de memoria, le asignamos una sentencia SELECT. Para controlar un cursor explícito, debemos seguir los siguientes pasos:
1. Declaramos el cursor en DECLARE.
2. Se abre el cursor con OPEN, y estamos en la primera posición.

42
3. Leemos la primera fila con FETCH.
4. Comprobamos si ha leído algo, y cerramos el cursor con CLOSE.
La sintaxis de declaración de un cursor, es la siguiente: CURSOR nombre_cursor IS SELECT [lista_de variables] FROM nombre_tabla; Donde la sentencia SELECT, es una sentencia cualquiera, que puede incluir cualquier tipo de restricción. La sintaxis de las ordenes open y close es: OPEN nombre_cursor; CLOSE nombre_cursor; Cuando queramos recuperar información del cursor, deberemos utilizar la orden FETCH, con la siguiente sintaxis: FETCH nombre_cursor INTO variable1, variable2,.....; Orden que devolverá una fila cada vez que sea ejecutada, y avanzará a la siguiente posición dentro de las filas que devuelve la consulta especificada en la declaración del cursor. El funcionamiento de los atributos de los cursores vistos anteriormente (%ROWCOUNT, %FOUND, %NOTFOUND, %ISOPEN) es similar, solo que el valor de %ISOPEN, puede ser TRUE en este caso si el cursor esta abierto. Existe un tipo de bucle para los cursores, que ejecuta automáticamente las ordenes OPEN, CLOSE y FETCH, y es el bucle FOR, cuya sintaxis es la siguiente: FOR record_name IN cursor_name LOOP statements; ....... END LOOP; En caso de no usar este bucle, se debería especificar la condición de salida que puede ser cuando el cursor haya recorrido todas las filas, en ese caso, la condicion sera: EXIT WHEN nombre_cursor%NOTFOUND;

43
Por ejemplo, voy a escribir dos formas de realizar la misma acción, una mediante el bucle FOR antes mencionado, y otra mediante la forma clásica, así, mediante la forma clásica, podríamos hacer: DECLARE CURSOR c1 IS SELECT empno, ename FROM emp; emp_record c1%ROWTYPE; BEGIN OPEN c1; LOOP FETCH c1 INTO emp_record; dbms_output.put_line(to_char(emp_record.empno)); dbms_output.put_line(emp_record.ename); EXIT WHEN c1%NOTFOUND; END LOOP; CLOSE c1; END; / Sin embargo, esto puede realizarse de forma mucho más sencilla, utilizando el bucle LOOP de la siguiente manera: DECLARE CURSOR c1 IS SELECT empno, ename FROM emp; emp_record c1%ROWTYPE; BEGIN FOR emp_record IN c1 LOOP dbms_output.put_line(to_char(emp_record.empno)); dbms_output.put_line(emp_record.ename); END LOOP; END; /

Manual SQL Oracle: Consultas, Modificación y Manipulación Datos

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Manual SQL Oracle: Consultas, Modificación y Manipulación Datos

Ähnlich wie Manual SQL Oracle: Consultas, Modificación y Manipulación Datos (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Manual SQL Oracle: Consultas, Modificación y Manipulación Datos