Curso de SQL - UTEZ Contenido

Introduccin ....................................................................................................................................................... 3 1. Comandos....................................................................................................................................................... 4 1.1 Comandos DLL .................................................................................................................................... 4

1.2 Comandos DML ........................................................................................................................................ 4 2. Clausulas ......................................................................................................................................................... 5 2.1 Comando Descripcin .............................................................................................................................. 5 3. Operadores..................................................................................................................................................... 6 3.1 Operadores Lgicos .................................................................................................................................. 6 3.2 Operadores de Comparacin ................................................................................................................... 6 4. Funciones de agregado .................................................................................................................................. 7 5. Consultas ........................................................................................................................................................ 8 5.1 Consultas de Seleccin ............................................................................................................................. 8 5.1.1 Consultas bsicas............................................................................................................................... 8 5.1.2 Ordenar los registros ......................................................................................................................... 8 5.2 Consultas con Predicado .......................................................................................................................... 8 6. Alias ................................................................................................................................................................ 9 7. Recuperacin de datos ................................................................................................................................. 10 7.1 operadores y comandos lgicos ............................................................................................................. 12 7.2 Operadores aritmticos y su precedencia ............................................................................................. 13 7.3 DEFINICION DEL VALOR NULL (Valores nulos) ....................................................................................... 13 8. Funciones SQL .............................................................................................................................................. 15 8.1 Funciones a nivel de fila ......................................................................................................................... 15 8.1.1 FUNCIONES DE CARACTERES........................................................................................................... 15 8.1.2 FUNCIONES NUMRICAS ................................................................................................................. 16 8.1.3 FUNCIONES DE FECHA ..................................................................................................................... 17 8.1.4 FUNCION NVL .................................................................................................................................. 18 8.2 Funciones a nivel de grupo de filas ........................................................................................................ 18

9. Recuperacin de datos. (Grupo de datos) ................................................................................................... 20 9.1 Exclusin de resultados (HAVING) ......................................................................................................... 21 10. Recuperacin de datos. (Relacionando tablas / JOIN) ............................................................................... 22 10. 1 Seccin a:............................................................................................................................................. 22 10. 2 Seccin b: ............................................................................................................................................ 25 10.2.1 Combinacin interna ..................................................................................................................... 25 10.2.2 Combinacin externa .................................................................................................................... 26 10.2.3 Unin ............................................................................................................................................. 27

Introduccin
SQL es un lenguaje que puede utilizarse dentro de lenguajes de programacin principales para transferir informacin seleccionada desde una base de datos. SQL tambin puede controlar el acceso a los recursos de la base de datos. SQL difiere de muchos lenguajes de programacin y de datos en que no es necesario codificar una secuencia de instrucciones para obtener los datos. SQL permite seleccionar, borrar y/o actualizar los datos usando una sola sentencia. Tambin nos proporciona la posibilidad de definir datos. A las instrucciones de seleccin y/o manipulacin de datos se les llama DML (Data Manipulation Language) y a las instrucciones de definicin de datos u objetos de la base de datos se las conoce por instrucciones DDL (Data Definition Language). A continuacin se presenta una serie de definiciones bsicas para el buen entendimiento del tema y que forman parte de casi todos los lenguajes de programacin que soportan SQL: Llamamos SQL dinmico a las sentencias que se preparan y procesan en un programa durante la ejecucin del mismo. Estas sentencias pueden ser variadas en tiempo de ejecucin, haciendo as muy flexible su utilizacin. Llamamos SQL esttico a las sentencias incluidas en un programa y que se preparan antes de la ejecucin. Son sentencias fijas aunque puedan variarse algunos de sus parmetros. Una Consulta es la instruccin bsica de SQL y se define, como ya veremos con la sentencia SELECT. Una Subconsulta es una consulta dentro de una condicin de bsqueda que hace referencia a un valor o conjunto de valores que se necesitan para responder a la consulta principal (es una SELECT dentro de otra SELECT). Una subconsulta puede incluir condiciones de bsqueda propias (incluyendo nuevas subconsultas) o ligadas a la consulta principal. En este ltimo caso, al conjunto total lo llamamos consulta sincronizada. Los Objetos SQL son las Bases de Datos, las Tablas, las Vistas, ndices, etc... Dependiendo del lenguaje principal, habr ms o menos objetos SQL. Los objetos SQL se crean mediante instrucciones DDL, que normalmente se almacenan en scripts de texto para poder recrearlos en cualquier momento. Los objetos SQL son mantenidos por el gestor de base de datos correspondiente.

1. Comandos
Existen dos tipos de comandos SQL: DLL: permiten crear y definir nuevas bases de datos, campos e ndices. DML: permiten generar consultas para ordenar, filtrar y extraer datos de la base de datos.

1.1 Comandos DLL

CREATE Crea nuevas tablas, campos e ndices DROP Elimina tablas e ndices ALTER Modifica las tablas agregando campos o cambiando la definicin de los campos.

1.2 Comandos DML

SELECT Consulta registros de la base de datos que satisfagan un criterio determinado INSERT Carga lotes de datos en la base de datos en una nica operacin. UPDATE Modifica los valores de los campos y registros especificados DELETE Elimina registros de una tabla de una base de datos

2. Clausulas
Son condiciones de modificacin utilizadas para definir los datos que desea seleccionar o manipular.

2.1 Comando Descripcin

FROM Especifica la tabla de la cual se van a seleccionar los registros. WHERE Especifica las condiciones que deben reunir los registros que se van a seleccionar. GROUP BY Separa los registros seleccionados en grupos especficos. HAVING Expresa la condicin que debe satisfacer cada grupo. ORDER BY Ordena los registros seleccionados de acuerdo con un orden especfico.

3. Operadores
3.1 Operadores Lgicos
AND Es el "y" lgico. Evala dos condiciones y devuelve un valor de verdad slo si ambas son ciertas. OR Es el "o" lgico. Evala dos condiciones y devuelve un valor de verdad si alguna de las dos es cierta. NOT Negacin lgica. Devuelve el valor contrario de la expresin.

3.2 Operadores de Comparacin

< > <> <= >= Menor que Mayor que Distinto de Menor Igual que Mayor Igual que Especifica un intervalo de valores. Comparacin de un modelo Especifica registros de una base de datos

BETWEEN LIKE In

4. Funciones de agregado
Las funciones de agregado se usan dentro de una clusula SELECT en grupos de registros para devolver un nico valor que se aplica a un grupo de registros. AVG Calcula el promedio de los valores de un campo determinado COUNT Devuelve el nmero de registros de la seleccin SUM Devuelve la suma de todos los valores de un campo determinado MAX Devuelve el valor ms alto de un campo especificado MIN Devuelve el valor ms bajo de un campo especificado

5. Consultas
5.1 Consultas de Seleccin
Las consultas de seleccin se utilizan para indicar al motor de datos que devuelva informacin de las bases de datos, esta informacin es devuelta en forma de conjunto de registros que se pueden almacenar en un objeto recordset. Este conjunto de registros es modificable. 5.1.1 Consultas bsicas La sintaxis bsica de una consulta de seleccin es la siguiente:
SELECT Campos FROM Tabla;

En donde campos es la lista de campos que se deseen recuperar y tabla es el origen de los mismos, por ejemplo:
SELECT Nombre, Telfono FROM Clientes;

Esta consulta devuelve un recordset con el campo nombre y telfono de la tabla clientes. 5.1.2 Ordenar los registros Se puede especificar el orden en que se desean recuperar los registros de las tablas mediante la clusula ORDER BY Lista de Campos. En donde Lista de campos representa los campos a ordenar.

5.2 Consultas con Predicado

El predicado se incluye entre la clusula y el primer nombre del campo a recuperar, los posibles predicados son: ALL Devuelve todos los campos de la tabla TOP Devuelve un determinado nmero de registros de la tabla DISTINCT Omite los registros cuyos campos seleccionados coincidan totalmente DISTINCROW Omite los registros duplicados basndose en la totalidad del registro y no slo en los campos seleccionados.

6. Alias
En determinadas circunstancias es necesario asignar un nombre a alguna columna determinada de un conjunto devuelto. Para ello se tiene la palabra reservada AS que se encarga de asignar el nombre que deseamos a la columna deseada. Podemos hacer que la columna devuelta por la consulta, en lugar de llamarse apellido (igual que el campo devuelto) se llame Empleado, o tambin asignar un nombre a una tabla como se muestra en el segundo ejemplo. En este caso procederamos de la siguiente forma:
SELECT DISTINCTROW Apellido AS Empleado FROM Empleados; SELECT DISTINCTROW Apellido AS Empleado FROM Empleados AS E;

7. Recuperacin de datos
Para la recuperacin de datos (filas) de una tabla, se dispone de la sentencia SELECT (que ya hemos mencionado antes) y cuya estructura bsica es la siguiente (ya veremos que hay ms clausulas): SELECT <campo_1>[,<campo_2>,...<campo_n>] | * FROM <tabla_1> [alias_tabla_1][,<tabla_2> [alias_tabla_2],... <tabla_n> [alias_tabla_n]] [WHERE <condicin_de_seleccin>] [GROUP BY <agrupamiento> [HAVING <seleccin_de_grupos>]] [ORDER BY <campos_de_ordenacin> [DESC|ASC]]; Los elementos entre corchetes son opcionales y la | indica una opcin u otra, de forma excluyente y el smbolo * indica que queremos recuperar todos los campos de cada fila de la tabla. Tambin hay que destacar que para nombrar un campo se puede hacer por su nombre o por su nombre completo, es decir, con la notacin nombre_tabla.nombre_campo, para evitar ambigedades entre campos del mismo nombre en distintas tablas. Observar que las sentencias SQL terminan siempre con un punto y coma (;). Veamos las partes de la SELECT por separado: SELECT <campo_1>[,<campo_2>,...<campo_n>] Son la relacin de campos a recuperar de la tabla. Si queremos recuperar todos los campos, usaremos el smbolo * pero, en este caso, el orden de los campos no ser especificado por nosotros. Los campos pueden ser expresiones aritmticas formadas por campos de las tablas, constantes u otras expresiones aritmticas. FROM <tabla_1> [alias_tabla_1][,<tabla_2> [alias_tabla_2],... <tabla_n> [alias_tabla_n]] Indicamos la(s) tabla(s) que intervienen en la consulta. Podemos renombrar una tabla mediante un alias para evitar teclear el nombre completo de las mismas. [WHERE <condicin_de_seleccin>] La clausula WHERE (donde) indica la condicin que han de cumplir los registros filas de la tabla que se recuperen. Tambin aparece aqu la unin entre las distintas tablas que puedan intervenir en la consulta, situacin que ya veremos ms adelante y las subconsultas ya mencionadas. [GROUP BY <agrupamiento> Agrupar por. Agrupa los resultados segn los campos de <agrupamiento>. [HAVING <seleccin_de_grupos>]] Teniendo... condiciones. Esta clausula va ligada a la de GROUP BY y sirve para aplicar condiciones de bsqueda a cada uno de los grupos obtenidos con GROUP BY. [ORDER BY <campos_de_ordenacin> [DESC|ASC]]

Ordenar por. Ordena las filas registros recuperados segn los <campos_de_ordenacin>. Si se indica ms de una columna, los resultados se ordenan primero por el primer campo, despus por el segundo, etc... La subclausula DESC indica orden descendente y ASC indica orden ascendente (que es la opcin por defecto). Vamos a ver algunos ejemplos sencillos de consulta. Supongamos que tenemos una tabla llamada EMPLEADOS con la siguiente estructura: NOMBRE DEL CAMPO TIPO DE DATO COMENTARIO
codigo nombre dni departamento salario fecha_alta jefe NUMBER(5) VARCHAR2(50) VARCHAR2(10) NUMBER(3) NUMBER(3) DATE NUMBER(5) Cdigo del empleado. Clave primaria. Nombre y apellidos del empleado. DNI/NIF del empleado. Cdigo de departamento al que pertenece Salario del empleado. Fecha de contratacin del empleado. Cdigo del jefe del empleado.

Queremos recuperar el nombre y el dni de todos los empleados. Para ello necesitamos usar la tabla EMPLEADOS. La consulta podra ser: SELECT nombre, dni FROM EMPLEADOS; SELECT EMPLEADOS.nombre, EMPLEADOS.dni FROM EMPLEADOS; SELECT e.nombre, e.dni FROM EMPLEADOS e; En esta ltima hemos utilizado el alias e para nombrar a la tabla EMPLEADOS, con lo que se simplifica bastante la nomenclatura nombre_tabla.nombre_campo. Si quisiramos ordenarla por orden alfabtico sera (en el caso ms simple): SELECT nombre, dni FROM EMPLEADOS ORDER BY nombre; Tambin podemos especificar el orden por el nmero de campo, es decir: ORDER BY 1 u ORDER BY 2. Pongamos por caso que ahora queremos recuperar los nombres y dni's de los empleados del departamento de ventas (el que tiene cdigo 1). La sentencia sera como la siguiente: SELECT nombre, dni FROM EMPLEADOS WHERE departamento=1 ORDER BY nombre; Ahora veamos algn ejemplo con la clausula GROUP BY. Ahora queremos saber cuntos empleados tenemos en el citado departamento de ventas, as que tendremos que contarlos no?. Para ello usaremos la funcin COUNT() de SQL (las funciones ms usadas las veremos en siguientes captulos) que baste decir, de momento, que sirve para contar registros. SELECT COUNT(*) FROM EMPLEADOS WHERE departamento=1; Vale, pero ahora queremos que nos muestre el departamento y cuantos empleados tiene cada uno de ellos. Para ello vamos a agrupar por.... departamento, efectivamente: SELECT departamento, COUNT(*) FROM EMPLEADOS GROUP BY departamento;

Y para acabar con estos ejemplos bsicos de recuperacin de datos, usaremos la clausula HAVING. Ahora lo que vamos a hacer es recuperar, como antes, los departamentos y su nmero de empleados pero solo los que tienen ms de 3 empleados. SELECT departamento, COUNT(*) FROM EMPLEADOS GROUP BY departamento HAVING COUNT(*)>3 ; Ms adelante, cuando hablemos de las funciones de grupo como puede ser COUNT(), SUM() y otras ms, veremos que al ponerlas en una sentencia SELECT, estaremos obligados a agrupar por el resto de campos que no sean funciones de grupo. Para finalizar, diremos que las clausulas que hemos visto no son todas las que son. Tampoco hemos visto las subconsultas, ya que merecen un apartado solo para ellas. Seguiremos viendo la sentencia SELECT en las siguientes secciones a medida que vayamos viendo conceptos.

7.1 operadores y comandos lgicos

Estos operadores los utilizaremos en varias clausulas de las sentencias SQL, sobre todo en la clausula WHERE. OPERADOR
IGUAL DISTINTO MENOR MAYOR MENOR IGUAL MAYOR IGUAL O Y ENTRE (RANGO) EN COMO NO ES NULO

SIMBOLO
= <> != < > <= >= OR AND BETWEEN IN LIKE NOT IS

EJEMPLO DE USO
departamento=1 departamento <> 1 departamento < 4 departamento > 4 departamento <= 4 departamento >= 4 departamento=1 OR departamento=2 nombre='JOSE MARTINEZ' AND departamento=2 departamento BETWEEN 1 AND 5 departamento IN (1,2,5,10) nombre LIKE 'JOSE%' nombre NOT LIKE 'JOSE%' NULL departamento IS NULL

NOTA: El smbolo % se usa como comodn. Es decir, en el ejemplo del operador LIKE hemos puesto: nombre LIKE 'JOSE%' Esto quiere decir que los nombres empiecen por JOSE y el resto de la cadena que haya en nombre nos da igual. Efectivamente, como ya estas pensando, podramos poner el comodn delante tambin: nombre LIKE '%MARTINEZ%' As seleccionamos todos los registros cuyo campo nombre contenga la cadena 'MARTINEZ', es decir, todos los 'MARTINEZ' de la tabla. El smbolo _ denota un solo carcter y su utilizacin es anloga a la del smbolo %.

Si se desea una coincidencia exacta para los comodines, se usa la opcin ESCAPE. Dicha opcin especifica cul es el carcter de ESCAPE. Por ejemplo, para visualizar los nombres de empleados cuyo nombre contiene N_A usaramos la siguiente sentencia SQL: SELECT nombre FROM EMPLEADOS WHERE nombre LIKE '%A\_B%' ESCAPE '\' ; PRECEDENCIA DE LOS OPERADORES Todos los operadores de comparacin NOT AND OR

7.2 Operadores aritmticos y su precedencia

Los operadores aritmticos son usados para crear expresiones aritmticas. stas pueden estar formadas por nombres de campos, valores constantes y operadores aritmticos. OPERADOR DESCRIPCION + * / Suma Resta Multiplicacin Divisin

Se pueden usar los operadores aritmticos en cualquier sentencia SQL excepto en la clausula FROM. SELECT nombre, salario, salario * 2.06 FROM EMPLEADOS ; Respecto a la precedencia de los operadores, si una expresin aritmtica contiene ms de un operador, la multiplicacin y la divisin se evalan primero. Si los operadores dentro de una expresin tienen la misma prioridad se evalan de izquierda a derecha. Podemos utilizar parntesis para forzar el orden de evaluacin de los operadores aritmticos y para clarificar las sentencias. Resumiendo: 1. La multiplicacin y la divisin tienen igual prioridad pero mayor que la suma y la resta. 2. La suma y la resta tienen la misma prioridad. 3. Usaremos parntesis para obligar a que la expresin encerrada en ellos se evale primero.

7.3 DEFINICION DEL VALOR NULL (Valores nulos)

Si un registro carece de valor para un campo en particular se dice que es un valor NULL, o que contiene un NULL. NULL es un valor inaccesible, sin valor, desconocido o inaplicable.

Un valor nulo no representa ni un cero ni un espacio en blanco. Las columnas o campos de cualquier tipo de datos pueden contener valores nulos excepto si se ha especificado como NOT NULL al crear la tabla o si es una clave primaria. Hay que tener especial atencin con los valores NULL a la hora de evaluar expresiones aritmticas, ya que si en una expresin, cualquier valor es nulo, el resultado tambin lo ser. Por ejemplo, una divisin por cero nos dar un error, pero una divisin por NULL nos dar un nulo. Para controlar la evaluacin de los valores NULL, disponemos de la funcin NVL que nos devolver un valor por defecto en caso de que su argumento sea un valor nulo.

8. Funciones SQL
Ya hemos nombrado alguna que otra funcin SQL por lo que vamos a explicar lo que son, para qu se usan y cules son las ms importantes. Las funciones son una caracterstica muy importante en cualquier lenguaje y en SQL no poda ser de otro modo. Las usaremos para: Realizar clculos sobre datos Modificar items de datos particulares Manipular la salida de grupos de filas Modificar formato de los datos para su presentacin Convertir los tipos de datos de las columnas. Como todas las funciones, aceptan argumentos y devuelven un valor valores. Vamos a dividir esta seccin en dos: Funciones a nivel de fila Funciones a nivel de grupos de filas, o funciones de grupo.

8.1 Funciones a nivel de fila

Estas funciones operan solo sobre filas y devuelven un nico resultado por cada una de ellas. Hay una gran variedad de ellas, pero veremos las de carcter, nmero, fecha y conversin. Las caractersticas ms relevantes de las funciones de fila son: Devuelven un resultado para cada fila recuperada Pueden devolver un dato de diferente tipo que el referenciado Se pueden usar en las clausulas SELECT, WHERE y ORDER BY Se pueden anidar

8.1.1 FUNCIONES DE CARACTERES Estas funciones aceptan caracteres como datos de entrada y pueden devolver caracteres o nmeros. Podramos subdividirlas en dos: funciones de conversin (LOWER, UPPER, INITCAP) y de manipulacin de caracteres (CONCAT, SUBSTR, LENGTH, INSTR, LPAD, RPAD).

Vamos a verlas de una en una con un pequeo ejemplo que deje claro su funcionamiento: Funciones de conversin: LOWER: Convierte en minsculas la cadena de caracteres. UPPER: Convierte en maysculas la cadena de caracteres. INITCAP: Convierte la primera letra de cada palabra a maysculas. Funcin LOWER('Curso de SQL') UPPER('Curso de SQL') INICAP('Curso de SQL') Resultado curso de sql CURSO DE SQL Curso De Sql

Funciones de manipulacin de caracteres: CONCAT: Concatena valores. Slo dos parmetros. Para concatenar ms cadenas, usaremos el operador de concatenacin ( || en el caso de Oracle) SUBSTR: Extrae una cadena de una longitud y desde una posicin. LENGTH: Devuelve la longitud de una cadena en formato numrico. LPAD: Justifica a la derecha con un carcter determinado. RPAD: Justifica a la izquierda con un carcter determinado. Funcin CONCAT('Hola',' Mundo') SUBSTR('Curso de SQL',7,2) LENGTH('Hola') LPAD(5000,10,'*') RPAD(5000,10,'*') Resultado Hola Mundo de 4 ******5000 5000******

8.1.2 FUNCIONES NUMRICAS Las funciones numricas aceptan nmeros como datos de entrada y devuelven valores numricos. Las ms usuales son ROUND, TRUNC y MOD. ROUND: Redondea un valor al decimal especificado. TRUNC: Trunca un valor en el decimal especificado. MOD: Devuelve el resto de la divisin. Funcin
ROUND(166.386,2) TRUNC(166.386,2) MOD(25,4)

Resultado
166.39 166.38 1

NOTA: Si el segundo argumento de MOD es cero, el resultado es el primer argumento y NO cero.

8.1.3 FUNCIONES DE FECHA Para empezar, decir que podemos operar aritmticamente con las fechas. Sumar o restar un nmero a de una fecha, nos da otra fecha. Restar dos fechas nos devuelve los das entre esas fechas. Sumar horas a una fecha dividiendo la cantidad de horas por 24. Las siguientes funciones de fecha son usadas en Oracle, pero en cualquier otra base de datos deben aparecer sus anlogas o las mismas. MONTHS_BETWEEN: Nmero de meses entre dos fechas. Puede ser negativo si la primera fecha es menor que la segunda. ADD_MONTHS: Agregar meses a una fecha. El nmero de meses a agregar puede ser negativo. NEXT_DAY: Prximo da de la fecha especificada. LAST_DAY: ltimo da del mes de la fecha. ROUND: Redondea una fecha segn el formato especificado. TRUNC: Trunca una fecha segn el formato especificado. TO_CHAR: Convierte a caracteres una fecha segn el formato. TO_DATE: Convierte a fecha una cadena de caracteres vlida. Funcin
MONTHS_BETWEEN('01/10/2003','01/12/2003') ADD_MONTHS('11/01/1994',6) NEXT_DAY('01/02/2004','FRIDAY') LAST_DAY('02/02/2004') ROUND('25/07/2003','MONTH') ROUND('25/07/2003','YEAR') TRUNC('25/07/2003','MONTH') TRUNC('25/07/2003','YEAR') TO_CHAR(fecha_alta,'DD/MM/RR') TO_CHAR(fecha_alta,'DD/MM/RRRR HH:MI') TO_DATE('01/01/04','DD/MM/RRRR')

Resultado

2 11/07/1994 06/02/2004 29/02/2004 01/08/2003 01/01/2004 01/07/2003 01/01/2003 '01/01/04' '01/01/2004 10:05' 01/01/2004

Ya hemos visto algn ejemplo de la funcin TO_CHAR usndola con fechas, ahora volvemos un poco atrs y la usaremos con nmeros.
TO_CHAR(numero,'formato')

El formato que se le pasa como argumento aparte del nmero a convertir a carcter, determinar el resultado final de la conversin. Usaremos estos formatos combinados para mostrar el resultado: Elemento
9 0

Descripcin
Posicin numrica. El n de 9's determinar el ancho de visualizacin Muestra ceros a la izquierda o detrs del punto decimal. Punto decimal en la posicin Coma en la posicin especificada

ejemplo
999999 00099.90

Resultado
1234 01234.00

. 99999.90 1234.00 , 999,999 1,234 Y terminamos con la funcin TO_NUMBER(char) que es la contraria a TO_CHAR, pero ms simple, ya que la cadena de caracteres debe ser vlida si no queremos obtener un error.

Funcin TO_NUMBER('09876') TO_NUMBER('98.76) TO_NUMBER('1,345.98')

Resultado 9876 98.76 ERROR (por la ,)

8.1.4 FUNCION NVL Esta funcin, como ya hemos comentado antes, previene los resultados errticos de las expresiones aritmticas que incluyen NULL en alguno de sus elementos. Cmo? Pues simplemente establece un valor para el caso de que el elemento sea NULL. As de sencillo. Es decir que si en una expresin ponemos NVL(departamento,0) y departamento es nulo, nos devolver un cero. Quiz este ejemplo no sea el ms acertado, pero pensemos ahora en un % de comisin de un vendedor que evaluado con las ventas pueda darnos valores nulos. La cuestin se agrava si quisiramos sumar las comisiones de nuestros vendedores multiplicando primero las ventas individuales por su porcentaje de comisin. Los valores nulos seran arrastrados hasta darnos un total nulo, totalmente falso. El valor por defecto debe coincidir con el tipo de dato que estamos tratando.

8.2 Funciones a nivel de grupo de filas

Las funciones de grupo son funciones que operan sobre conjuntos de registros para dar un resultado a nivel de grupo. Dichos grupos pueden estar constituidos por la tabla entera o por partes de la misma. Estas funciones aparecen en las clausulas SELECT y HAVING. Estas son las ms comunes:
AVG([DISTINCT|ALL] n): Valor promedio de n, ignorando los valores nulos. COUNT({*|[DISTINCT|ALL] expr}): Cantidad de filas cuando expr da un valor no nulo. Para contar

todas las filas (incluyendo duplicadas y valores nulos) usaremos *. MAX([DISTINCT|ALL] expr): Valor mximo de expr. MIN([DISTINCT|ALL] expr): Valor mnimo de expr. STDDEV([DISTINCT|ALL]x): Desviacin estndar de x, ignorando los nulos. SUM([DISTINCT|ALL]n): Suma los valores de n ignorando los nulos. VARIANCE([DISTINCT|ALL]x): Varianza de n ignorando los valores nulos. DISTINCT hace que la funcin considere slo los valores no duplicados, mientras que ALL incluye todos (es el valor por defecto). Los tipos de datos de los argumentos de expr pueden ser CHAR, VARCHAR2, NUMBER o DATE. Todas las funciones de grupo excepto COUNT(*) ignoran los valores nulos. Para evitar esto podemos usar la funcin NVL para sustituir el valor NULL por otro valor. AVG y SUM se usan para datos numricos. MIN y MAX se usan para cualquier tipo de dato.

Veamos unos cuantos ejemplos: Obtener la media, salario ms alto, ms bajo y la suma de salarios para el departamento de ventas (sin tener en cuenta los nulos):

SELECT AVG(salario), MAX(salario), MIN(salario), SUM(salario) FROM EMPLEADOS WHERE departamento=1 ; Obtener la media, salario ms alto, ms bajo y la suma de salarios para el departamento de ventas teniendo en cuenta todos los valores: SELECT AVG(NVL(salario,0)), MAX(NVL(salario,0)), MIN(NVL(salario,0)), SUM(NVL(salario,0)) FROM EMPLEADOS WHERE departamento=1 ; Obtener la fecha de contratacin ms antigua y la ms moderna: SELECT MAX(fecha_alta), MIN(fecha_alta) FROM EMPLEADOS ; Obtener el primer nombre de empleado alfabticamente y el ltimo: SELECT MAX(nombre), MIN(nombre) FROM EMPLEADOS ; Obtener el nmero de empleados del departamento de ventas: SELECT COUNT(*) FROM EMPLEADOS WHERE departamento=1; Obtener el nmero de empleados que tienen asignado jefe: SELECT COUNT(jefe) FROM EMPLEADOS ; Obtener el nmero de departamentos distintos que hay en EMPLEADOS. SELECT COUNT(DISTINCT(departamento)) FROM EMPLEADOS; Por ltimo, comentar que las funciones de grupo se pueden anidar como las dems funciones: SELECT MAX(AVG(salario)) FROM EMPLEADOS GROUP BY departamento ; Aqu calculamos la mxima de las medias de los salarios por departamento.

9. Recuperacin de datos. (Grupo de datos)

Despus de ver las funciones de grupo, ya podemos profundizar ms en las clausulas GROUP BY y HAVING de la sentencia SELECT. A veces necesitamos dividir la informacin de una tabla en grupos ms pequeos a la hora de la recuperacin de datos. Esto lo haremos con GROUP BY. El siguiente ejemplo muestra el nmero de departamento y el salario medio para cada uno de ellos. SELECT departamento, AVG(salario) FROM EMPLEADOS GROUP BY departamento ; Estas son una serie de reglas para el uso de GROUP BY y HAVING. Si se incluye una funcin de grupo en la sentencia SELECT, no se puede seleccionar resultados individuales a menos que la columna aparezca en la clausula GROUP BY. Con la clausula WHERE se pueden excluir filas antes de la divisin en grupos. No se puede usar un alias de campo columna en la clausula GROUP BY. Por defecto las filas se ordenan en forma ascendente de acuerdo a la lista GROUP BY. Esto se puede modificar con ORDER BY. La(s) columna(s) referenciada(s) por GROUP BY no es necesario seleccionarla(s) en la lista de campos a recuperar, aunque sin ella(s) los datos recuperados pueden no ser relevantes.
SELECT MAX(salario) FROM EMPLEADOS GROUP BY departamento ;

Se puede usar la funcin de grupo en la clausula ORDER BY.

SELECT AVG(salario) FROM EMPLEADOS GROUP BY AVG(salario) ;

Podemos agrupar por ms de una columna, creando grupos dentro de grupos

SELECT departamento, cargo, SUM(salario) FROM EMPLEADOS GROUP BY departamento, cargo ;

(Aqu hemos supuesto que disponemos de un campo columna llamada cargo que informa del puesto que ocupa cada empleado). La funcin SUM est siendo aplicada al salario para todos los cargos dentro de cada nmero de departamento. Para finalizar, veremos cmo excluir resultados de un grupo y como anidar funciones de grupo.

9.1 Exclusin de resultados (HAVING)

De la misma forma que usamos WHERE para restringir los registros que seleccionamos, usaremos HAVING para restringir grupos de registros. Es decir: los grupos que se correspondan con la clausula HAVING sern los mostrados. SELECT departamento, max(salario) FROM DEPARTAMENTOS GROUP BY departamento HAVING MAX(salario)>3000; Podemos utilizar la clausula GROUP BY sin utilizar una funcin de grupo en la SELECT: SELECT departamento FROM EMPLEADOS GROUP BY DEPARTAMENTO HAVING MAX(salario) > 3000; Por supuesto podemos ordenar los resultados: SELECT cargo, SUM(salario) FROM EMPLEADOS WHERE cargo NOT LIKE 'VENDEDOR%' GROUP BY cargos HAVING SUM(salario) > 5000 ORDER BY SUM(salario) ; En este ltimo ejemplo vemos como la clausula WHERE restringe los registros antes de que se calculen los grupos y se excluyan resultados mediante HAVING. La clausula HAVING puede ponerse antes de la clausula GROUP BY pero no se recomienda por lgica. Los grupos se forman, y las funciones de grupo se calculan antes de que la clausula HAVING sea aplicada a los grupos.

10. Recuperacin de datos. (Relacionando tablas / JOIN)

10. 1 Seccin a:
En los ejemplos anteriores hemos visto un campo en la tabla EMPLEADOS llamado departamento. Adems vemos que es un cdigo numrico ue debe hacer referencia a otra tabla que contenga los departamentos de la empresa. Es decir, que tenemos una tabla DEPARTAMENTOS con la siguiente estructura: NOMBRE DEL CAMPO TIPO DE DATO
codigo nombre NUMBER(5) VARCHAR2(30)

COMENTARIO
Cdigo del departamento. Clave primaria Nombre del departamento

Al campo EMPLEADOS.departamento se le llama clave ajena (Foreign key) donde el campo DEPARTAMENTOS.codigo es la clave primaria. Recordemos que una clave primaria siempre es nica, pero una clave nica no tiene por qu ser la clave primaria de una tabla. Tambin decir que una clave ajena tiene que coincidir con un valor de una clave primaria ya existente o con un valor de una clave nica ya que en otro caso deber ser NULL. Por ltimo, una clave ajena puede hacer referencia a una clave primaria o una clave nica en la propia tabla. Por ejemplo, tenemos el caso del campo jefe en la tabla EMPLEADOS, que es una clave ajena que referencia al campo codigo de empleado de la propia tabla EMPLEADOS. Es decir, se almacena el cdigo del empleado que es el jefe del empleado actual. Debido a que los datos sobre diferentes entidades se almacenan en tablas diferentes, podramos necesitar combinar dos o ms tablas para responder a una solicitud de recuperacin de datos. Por ejemplo, queremos saber el nombre de cada departamento donde trabajan los empleados. Est claro que necesitamos informacin de la tabla EMPLEADOS que contiene los datos de los empleados y de la tabla DEPARTAMENTOS que contiene el nombre de los mismos. Para realizar la consulta debemos relacionar las dos tablas mediante la clave ajena departamento de EMPLEADOS y la clave primaria codigo de DEPARTAMENTOS. Primero veremos lo que es un join. Cuando necesitamos datos de ms de una tabla de la base de datos, se utiliza una condicin join. Las filas de una tabla pueden unirse a las de otra segn los valores comunes existentes en las mismas, osea, los valores de clave ajena y de clave primaria. La condicin de join la especificamos en la clausula WHERE:
SELECT e.nombre, e.dni, d.nombre FROM EMPLEADOS e, DEPARTAMENTOS d WHERE e.departamento = d.codigo

Bastante claro, no?. Es evidente que cualquier departamento grabado en EMPLEADOS deber estar en DEPARTAMENTOS, pero podra darse el caso de que un empleado tuviera en el campo departamento un nulo (NULL). Es decir, que el trabajador no estuviera asignado a ningn departamento, por ejemplo, el Director General. En este caso, nos daremos cuenta que con la SELECT anterior no aparecen estos registros ya que no hay coincidencia en la clausula WHERE. Imaginemos ahora los registros de una tabla de clientes que no tienen asignado todava un comercial fijo que les atienda. Es ms, no es obligatorio que lo tenga. Cmo podramos obtener en una consulta los

clientes y los nombres de los comerciales que los atienden si los que no tienen comercial no nos aparecen?. Qu se hace para remediar estas situaciones?. La respuesta son las outer join. Entonces.... tenemos varios tipos de joins?. S. Equijoin: Para determinar el nombre del departamento de un empleado, se compara el valor de la columna departamento de EMPLEADOS con los valores de codigo de la tabla DEPARTAMENTOS. La relacin entre ambas es un equijoin, es decir los valores deben ser iguales. Los equijoins tambin son llamados inner joins (esto es terminologa para que os suene). El ejemplo anterior es un equijoin. Non-equijoins: Son las joins en las que la condicin no es de igualdad. Para comprender esto vamos a suponer otra nueva tabla llamada NIVEL_SALARIAL con esta estructura: NOMBRE DEL CAMPO
nivel salario_min salario_max

TIPO DE DATO
NUMBER(5) NUMBER(15,2) NUMBER(15,2)

COMENTARIO
Nivel salarial. Clave primaria Salario mnimo del nivel actual. Salario mximo del nivel actual.

Como haramos par obtener el nivel salarial de cada empleado? SELECT e.nombre, e.salario, n.nivel FROM EMPLEADOS e, NIVEL_SALARIAL n WHERE e.salario BETWEEN n.salario_min AND n.salario_max; outer joins: Se usan para devolver registros sin coincidencias directas. Si una fila no satisface la condicin de join, no aparecer en los resultados de la consulta. Por ejemplo, si no hay ningn empleado que trabaje en un departamento, ste no aparecer: SELECT e.nombre, e.departamento, d.nombre FROM EMPLEADOS e, DEPARTAMENTOS d WHERE e.departamento = d.codigo ; Para obtener las filas que no aparecen usaremos el operador del outer join, que es el (+) SELECT e.nombre, e.departamento, d.nombre FROM EMPLEADOS e, DEPARTAMENTOS d WHERE e.departamento(+) = d.codigo; El operador se coloca en el lado del join que es deficiente en informacin. El operador outer join puede aparecer solo en un lado de la expresin. Este recupera las filas de una tabla que no tiene correspondencia directa en la otra tabla. Una condicin que incluye una outer join no puede utilizar el operador IN o unirse a otra condicin por el operador OR, pero s podemos usar el operado AND. Self joins: Es cuando necesitamos combinar una tabla consigo misma. Por ejemplo, para encontrar el nombre del jefe de cada empleado necesitamos combinar la tabla EMPLEADOS consigo misma ya que un jefe tambin es un empleado y, como tal, se encuentra tambien en la tabla EMPLEADOS. En estos casos miramos dos veces la misma tabla, una para recuperar al empleado y otra para recuperar el nombre del jefe. SELECT trab.nombre EMPLEADO, jefes.nombre JEFE FROM EMPLEADOS trab, EMPLEADOS jefes WHERE trab.jefe = jefes.codigo ; Como se ve, hemos referenciado la misma tabla EMPLEADOS dos veces con diferentes alias de tabla, simulando as tener dos tablas y hemos hecho el join con los campos jefe y codigo.

Ahora bien, qu pasa si omitimos una condicin de join o la condicin es invlida?. La respuesta se llama Producto Cartesiano y su nombre refleja exactamente lo que ocurre: Se combinan todas las tablas de la primera tabla con todas las filas de la segunda. El producto cartesiano genera una gran cantidad de filas y este resultado es raramente til. Por ello debemos asegurarnos de incluir siempre una condicin de join vlida en la clausula WHERE. Si quieres un ejemplo de producto cartesiano, simplemente quitar la clausula WHERE del ejemplo anterior o de cualquiera de los ejemplos de joins anteriores. Bien, pues hemos visto cmo obtener datos de varias tablas relacionndolas mediante las claves primarias, claves ajenas y/o con joins. En caso de querer relacionar ms de dos tablas, el procedimiento es el mismo aadiendo ms tablas en la clausula FROM y las condiciones de unin correspondientes en la clausula WHERE. Por ejemplo, supongamos que disponemos de otra tabla llamada SALARIOS con la siguiente estructura: NOMBRE DEL CAMPO
empleado fecha_salario salario

TIPO DE DATO

NUMBER(5) DATE NUMBER(15,2)

COMENTARIO

Cdigo de empleado. Clave primaria Fecha de fijacin del salario. Salario

En este caso la primary key seran los campos empleado+fecha_salario ya que un empleado puede tener varios registros de salario a distintas fechas (histrico de salarios por empleado). Es evidente que el campo empleado es a su vez una clave ajena del campo codigo de la tabla EMPLEADOS. Ahora queremos obtener una lista de empleados, con el nombre del departamento donde trabajan (si no tienen departamento asignado, deben aparecer tambin), el nombre de su jefe y el sueldo del empleado hasta el 31/12/2003 (suponemos que un empleado siempre tiene sueldo, jejeje).
SELECT e.nombre EMPLEADO, d.nombre DEPART, j.nombre JEFE, s.salario SUELDO FROM EMPLEADOS e, EMPLEADOS j, DEPARTAMENTOS d, SALARIOS s WHERE e.departamento = d.codigo(+) AND e.jefe = j.codigo AND e.codigo = s.empleado AND s.fecha_salario = (SELECT MAX(fecha_salario) FROM SALARIOS sal WHERE sal.empleado = s.empleado AND TRUNC(fecha_salario)<=TO_DATE('31/12/03','DD/MM/RRRR'));

S ya s que en esta SELECT aparece algo nuevo. Se llama subconsulta y adems es de un tipo especial denominada sincronizada ya que en ella aparece un campo de la SELECT exterior que provoca que se sincronicen las dos. El tema de Subconsultas lo vamos a ver en el captulo siguiente. De momento quedaros con que hemos usado varias tablas con diferentes joins, hemos usado outer join, self join y non-equijoins. Tambin hemos usado funciones de grupo y de conversin de datos.

10. 2 Seccin b:
Habitualmente cuando necesitamos recuperar la informacin de una base de datos nos encontramos con que dicha informacin se encuentra repartida en varias tablas, referenciadas a travs de varios cdigos. De este modo si tuviramos una tabla de ventas con un campo cliente, dicho campo contendra el cdigo del cliente de la tabla de cliente. Sin embargo est forma de almacenar la informacin no resulta muy til a la hora de consultar los datos.SQL nos proporciona una forma fcil de mostrar la informacin repartida en varias tablas, las consultas combinadas o JOINS. Las consultas combinadas pueden ser de tres tipos: Combinacin interna Combinacin externa Uniones 10.2.1 Combinacin interna La combinacin interna nos permite mostrar los datos de dos o ms tablas a travs de una condicin WHERE. Realizar la consulta combinada entre estas dos tablas debemos escribir una consulta SELECT en cuya clausula FROM escribiremos el nombre de las dos tablas, separados por comas, y una condicin WHERE que obligue a que el cdigo de marca de la tabla de coches sea igual al cdigo de la tabla de marcas. Lo ms sencillo es ver un ejemplo directamente:
SELECT tCoches.matricula, tMarcas.marca, tCoches.modelo, tCoches.color, tCoches.numero_kilometros, tCoches.num_plazas FROM tCoches, tMarcas WHERE tCoches.marca = tMarcas.codigo

Otra opcin es utilizar la clusula INNER JOIN. Su sintaxis es idntica a la de una consulta SELECT habitual, con la particularidad de que en la clusula FROM slo aparece una tabla o vista, aadindose el resto de tablas a travs de clusulas INNER JOIN
SELECT [ALL | DISTINCT ] <nombre_campo> [{,<nombre_campo>}] FROM <nombre_tabla> [{INNER JOIN <nombre_tabla> ON <condicion_combinacion>}] [WHERE <condicion> [{ AND|OR <condicion>}]] [GROUP BY <nombre_campo> [{,<nombre_campo >}]] [HAVING <condicion>[{ AND|OR <condicion>}]] [ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC] [{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]

La clusula INNER JOIN permite separar completamente las condiciones de combinacin con otros criterios, cuando tenemos consultas que combinan nueve o diez tablas esto realmente se agradece. Sin embargo muchos programadores no son amigos de la clusula INNER JOIN. 10.2.2 Combinacin externa La combinacin interna es excluyente. Esto quiere decir que si un registro no cumple la condicin de combinacin no se incluye en los resultados. De este modo en el ejemplo anterior si un coche no tiene grabada la marca no se devuelve en mi consulta. Segn la naturaleza de nuestra consulta esto puede ser una ventaja , pero en otros casos significa un serio problema. Para modificar este comportamiento SQL pone a nuestra disposicin la combinacin externa. La combinacin externa no es excluyente. La sintaxis es muy parecida a la combinacin interna,
SELECT [ALL | DISTINCT ] <nombre_campo> [{,<nombre_campo>}] FROM <nombre_tabla> [{LEFT|RIGHT OUTER JOIN <nombre_tabla> ON <condicion_combinacion>}] [WHERE <condicion> [{ AND|OR <condicion>}]] [GROUP BY <nombre_campo> [{,<nombre_campo >}]] [HAVING <condicion>[{ AND|OR <condicion>}]] [ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC] [{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]

La combinacin externa puede ser diestra o siniestra, LEFT OUTER JOIN o RIGHT OUTER JOIN. Con LEFT OUTER JOIN obtenemos todos los registros de en la tabla que situemos a la izquierda de la clausula JOIN, mientras que con RIGHT OUTER JOIN obtenemos el efecto contrario. Como mejor se ve la combinacin externa es con un ejemplo.
SELECT tCoches.matricula, tMarcas.marca, tCoches.modelo, tCoches.color, tCoches.numero_kilometros, tCoches.num_plazas FROM tCoches LEFT OUTER JOIN tMarcas ON tCoches.marca = tMarcas.codigo

Esta consulta devolver todos los registros de la tabla tCoches, independientemente de que tengan marca o no. En el caso de que el coche no tenga marca se devolver el valor null para los campos de la tabla tMarcas.
El mismo ejemplo con RIGHT OUTER JOIN

SELECT tCoches.matricula, tMarcas.marca, tCoches.modelo, tCoches.color, tCoches.numero_kilometros, tCoches.num_plazas

FROM tCoches RIGHT OUTER JOIN tMarcas ON tCoches.marca = tMarcas.codigo

Esta consulta devolver los registros de la tabla tCoches que tengan marca relacionada y todos los registros de la tabla tMarcas, tengan algn registro en tCoches o no. 10.2.3 Unin

La clusula UNION permite unir dos o ms conjuntos de resultados en uno detrs del otro como si se tratase de una nica tabla. De este modo podemos obtener los registros de ms de una tabla "unidos". La sintaxis corresponde a la de varias SELECT unidas a travs de UNION, como se muestra a continuacin:
SELECT [ALL | DISTINCT ] <nombre_campo> [{,<nombre_campo>}] FROM <nombre_tabla> [{LEFT|RIGHT OUTER JOIN <nombre_tabla> ON <condicion_combinacion>}] [WHERE <condicion> [{ AND|OR <condicion>}]] [GROUP BY <nombre_campo> [{,<nombre_campo >}]] [HAVING <condicion>[{ AND|OR <condicion>}]] { UNION [ALL | DISTINCT ] SELECT [ALL | DISTINCT ] <nombre_campo> [{,<nombre_campo>}] FROM <nombre_tabla> [{LEFT|RIGHT OUTER JOIN <nombre_tabla> ON <condicion_combinacion>}] [WHERE <condicion> [{ AND|OR <condicion>}]] [GROUP BY <nombre_campo> [{,<nombre_campo >}]] [HAVING <condicion>[{ AND|OR <condicion>}]] } [ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC] [{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]

Para utilizar la clausula UNION debemos cumplir una serie de normas. Las consultas a unir deben tener el mismo nmero campos, y adems los campos deben ser del mismo tipo. Slo puede haber una nica clausula ORDER BY al final de la sentencia SELECT. El siguiente ejemplo muestra el uso de UNION
SELECT tCoches.matricula, tMarcas.marca, tCoches.modelo, tCoches.color, tCoches.numero_kilometros, tCoches.num_plazas FROM tCoches INNER JOIN tMarcas ON tCoches.marca = tMarcas.codigo UNION SELECT tMotos.matricula, tMarcas.marca, tMotos.modelo, tMotos.color, tMotos.numero_kilometros, 0 FROM tMotos INNER JOIN tMarcas ON tMotos.marca = tMarcas.codigo;

Puede observarse el uso de la constante cero en la segunda lista de seleccin para hacer coincidir el nmero y tipo de campos que devuelve la consulta UNION