Está en la página 1de 28

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) ....................................................................................... 14
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

BETWEEN

Especifica un intervalo de valores.

LIKE

Comparacin de un modelo

In

Especifica registros de una base de datos

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

SIMBOLO

EJEMPLO DE USO

IGUAL
DISTINTO
MENOR
MAYOR
MENOR IGUAL
MAYOR IGUAL
O
Y
ENTRE (RANGO)
EN
COMO
NO
ES NULO

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

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

Resultado

ROUND(166.386,2)
TRUNC(166.386,2)
MOD(25,4)

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

Resultado

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')

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

Descripcin

ejemplo

Resultado

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

999999

1234

00099.90

01234.00

99999.90
999,999

1234.00
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

COMENTARIO

codigo
nombre

Cdigo del departamento. Clave primaria


Nombre del departamento

NUMBER(5)
VARCHAR2(30)

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

TIPO DE DATO

COMENTARIO

nivel
salario_min
salario_max

NUMBER(5)
NUMBER(15,2)
NUMBER(15,2)

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

TIPO DE DATO

COMENTARIO

empleado
fecha_salario
salario

NUMBER(5)
DATE
NUMBER(15,2)

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

También podría gustarte