Facultad de Ingeniera de

Produccin y Servicios

Escuela Profesional de
Ingeniera Industrial

Integrantes:

Cceres Salas, Nikol Eleonore

DOCENTE:
Ing. Edwin Estremadoyro

Arequipa Per
2017
NDICE
SQL - JOIN ................................................................................................................................................... 3
JOIN ............................................................................................................................................................ 4
LEFT JOIN .................................................................................................................................................... 5
RIGTH JOIN ................................................................................................................................................. 5
INNER JOIN, LEFT OUTER JOIN, RIGHT OUTER JOIN ................................................................................. 7
Otros ejemplos ......................................................................................................................................... 10
SQL - JOIN
La sentencia SQL JOIN se utiliza para relacionar varias tablas, veremos algunos ejemplos
bsicos de distintos tipos de JOIN.

La sentencia JOIN (unir, combinar) de SQL permite combinar registros de una o ms tablas en
una base de datos relacional. En el Lenguaje de Consultas Estructurado (SQL) hay tres tipos
de JOIN: interno, externo y cruzado. El estndar ANSI del SQL especifica cinco tipos
de JOIN : INNER , LEFT OUTER , RIGHT OUTER , FULL OUTER y CROSS . Una tabla

puede unirse a s misma, produciendo una auto-combinacin, SELF-JOIN.

Matemticamente, JOIN es composicin relacional, la operacin fundamental en el lgebra

relacional, y, generalizando, es una funcin de composicin.
Primero creamos dos tablas para las pruebas

Tabla clientes:

mysql> select * from clientes;

+------+--------+----------+
| cid | nombre | telefono |
+------+--------+----------+
| 1 | jose | 111 |
| 2 | maria | 222 |
| 3 | manuel | 333 |
| 4 | jesus | 4444 |
+------+--------+----------+
4 rows in set (0.00 sec)

Tabla acciones:

mysql> select * from acciones;

+-----+-----+--------+----------+
| aid | cid | accion | cantidad |
+-----+-----+--------+----------+
| 1 | 2 | REDHAT | 10 |
| 2 | 4 | NOVELL | 20 |
| 3 | 4 | SUN | 30 |
| 4 | 5 | FORD | 100 |
+-----+-----+--------+----------+
4 rows in set (0.00 sec)

Observaciones de las tablas:

La primer tabla contiene clientes y telfonos y la segunda la tenencia de acciones de los

clientes.

Las dos tablas contienen el campo cid (client id) que es el que nos permitir realizar
coincidencias entre ambas tablas con join.

Hay clientes que no tienen acciones (jose) y otros que tienen ms de una especie (jesus).

El ltimo registro de la tabla acciones (aid=4) tiene un cid 5, si miramos la tabla cliente, no
existe un cliente con cid=5.

JOIN
El JOIN nos permitir obtener un listado de los campos que tienen coincidencias en ambas
tablas.

Osea nos dara un lista de los clientes que tienen acciones.

mysql> select nombre, telefono, accion, cantidad from clientes join acciones on
clientes.cid=acciones.cid;
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| maria | 222 | REDHAT | 10 |
| jesus | 4444 | NOVELL | 20 |
| jesus | 4444 | SUN | 30 |
+--------+----------+--------+----------+
3 rows in set (0.00 sec)

LEFT JOIN
La sentencia LEFT JOIN nos dar el resultado anterior mas los campos de la tabla clientes que
no tienen coincidencias.

Osea un listado de todos los clientes, con sus tenencias y en el caso que no tengan acciones
aparecer NULL (como es el caso de jose).

mysql> select nombre, telefono, accion, cantidad from clientes left join acciones on
clientes.cid=acciones.cid;
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| jose | 111 | NULL | NULL |
| maria | 222 | REDHAT | 10 |
| manuel | 333 | NULL | NULL |
| jesus | 4444 | NOVELL | 20 |
| jesus | 4444 | SUN | 30 |
+--------+----------+--------+----------+
5 rows in set (0.00 sec)

RIGTH JOIN
La sentencia RIGHT JOIN combina los valores de la primera tabla con los valores de la
segunda tabla. Siempre devolver las filas de la segunda tabla, incluso aunque no cumplan la
condicin.

En algunas bases de datos, la sentencia RIGHT JOIN es igual a RIGHT OUTER JOIN

SELECT * FROM tabla1 RIGHT JOIN tabla2 WHERE tabla1.columna1 = tabla2.columna1

EJEMPLO SQL RIGHT JOIN

per nombre apellido1 apellido2 dep

1 ANTONIO PEREZ GOMEZ 1

2 ANTONIO GARCIA RODRIGUEZ 2

3 PEDRO RUIZ GONZALEZ 4

Tabla "departamentos", con la clave primaria "dep"

dep departamento

1 ADMINISTRACION

2 INFORMATICA

3 COMERCIAL

SELECT nombre, apellido1, departamento

FROM personas
RIGHT JOIN departamentos
WHERE personas.dep = departamentos.dep

nombre apellido1 departamento

ANTONIO PEREZ ADMINISTRACION

ANTONIO GARCIA INFORMATICA

COMERCIAL

Aunque no exista ninguna persona del departamento 'COMERCIAL' (3), esta fila aparecer con
las otras columnas en blanco

Aqu se listarn todas las tenencias de acciones, tengan o no cliente, las que no tengan cliente se
vern como NULL (como es el caso de aid=4)

mysql> select nombre, telefono, accion, cantidad from clientes right join acciones on
clientes.cid=acciones.cid;
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| maria | 222 | REDHAT | 10 |
| jesus | 4444 | NOVELL | 20 |
| jesus | 4444 | SUN | 30 |
| NULL | NULL | FORD | 100 |
+--------+----------+--------+----------+
4 rows in set (0.00 sec)

INNER JOIN
Con esta operacin cada registro en la tabla A es combinado con los correspondientes de la
tabla B que satisfagan las condiciones que se especifiquen en el predicado del JOIN. Cualquier
registro de la tabla A o de la tabla B que no tenga uno correspondiente en la otra tabla es
excluido, y solo aparecern los que tengan correspondencia en la otra tabla. Este es el tipo
de JOIN ms utilizado, por lo que es considerado el tipo de combinacin predeterminado.

Como ejemplo, la siguiente consulta toma todos los registros de la tabla Empleado y encuentra
todas las combinaciones en la tabla Departamento. La sentencia JOIN compara los valores en la
columna IDDepartamento en ambas tablas. Cuando no existe esta correspondencia entre
algunas combinaciones, estas no se muestran; es decir, que si el nmero de departamento de un
empleado no coincide con los nmeros de departamento de la tabla Departamento, no se
mostrar el empleado con su respectivo departamento en la tabla resultante.

Las dos consultas siguientes son similares y se realizan de manera explcita (A) e implcita (B).

Ejemplo de la sentencia INNER JOIN explcita:

SELECT *
FROM empleado
INNER JOIN departamento
ON empleado.IDDepartamento = departamento.IDDepartamento

Ejemplo de la sentencia INNER JOIN implcita:

SELECT *
FROM empleado, departamento
WHERE empleado.IDDepartamento = departamento.IDDepartamento

Resultados:
 Empleado Departamento

Apellido IDDepartamento NombreDepartamento IDDepartamento

Zolano 34 Produccin 34

Jordn 33 Ingeniera 33

Rbinson 34 Produccin 34

Steinberg 33 Ingeniera 33

Andrade 31 Ventas 31

El empleado Gaspar y el departamento de Mercadeo no son presentados en los resultados ya

que ninguno de estos tiene registros correspondientes en la otra tabla. No existe un
departamento con nmero 36 ni existe un empleado con nmero de departamento 35.

Theta Join

A la combinacin que utiliza comparaciones dentro del predicado JOIN se le llama theta-join.
Se pueden hacer comparaciones de <, <=, =, <>, >= y >.

Ejemplo de combinacin tipo theta:

SELECT *
FROM empleado
INNER JOIN departamento
ON empleado.IDDepartamento < departamento.IDDepartamento

Las operaciones INNER JOIN puede ser clasificadas como de igualdad, naturales y cruzadas.

Equi-join

Es una variedad del theta-join que usa comparaciones de igualdad en el predicado JOIN.
Cuando se usan otros operadores de comparacin no se puede clasificar en este rango.
Ejemplo de combinacin de igualdad:

SELECT *
FROM empleado
INNER JOIN departamento
ON empleado.IDDepartamento = departamento.IDDepartamento

La tabla resultante presenta dos columnas llamadas IDDepartamento: una proveniente de la

tabla Empleado y otra de la tabla Departamento.

Natural join

Es una especializacin de la combinacin de igualdad, anteriormente mencionada, que se

representa por el smbolo . En este caso se comparan todas las columnas que tengan el mismo
nombre en ambas tablas. La tabla resultante contiene slo una columna por cada par de
columnas con el mismo nombre.

Ejemplo de combinacin natural:

SELECT *
FROM empleado NATURAL JOIN departamento

El resultado es un poco diferente al del ejemplo de la tabla anterior, ya que esta vez la columna
IDDepartamento se muestra sola una vez en la tabla resultante.

Empleado (campo comn) Departamento

Apellido IDDepartamento NombreDepartamento

Zolano 34 Produccin

Jordn 33 Ingeniera

Rbinson 34 Produccin
 Steinberg 33 Ingeniera

Andrade 31 Ventas

El uso de esta sentencia NATURAL puede producir resultados ambiguos y generar problemas
si la base de datos cambia, porque al aadir, quitar o renombrar las columnas puede perder el
sentido la sentencia; por esta razn es preferible expresar el predicado usando las otras
expresiones nombradas anteriormente.

Con esta operacin cada registro en la tabla A es combinado con los correspondientes de la
tabla B que satisfagan las condiciones que se especifiquen en el predicado del JOIN. Cualquier
registro de la tabla A o de la tabla B que no tenga uno correspondiente en la otra tabla es
excluido, y solo aparecern los que tengan correspondencia en la otra tabla. Este es el tipo
de JOIN ms utilizado, por lo que es considerado el tipo de combinacin predeterminado.

Las dos consultas siguientes son similares y se realizan de manera explcita (A) e implcita (B).

Ejemplo de la sentencia INNER JOIN explcita:

SELECT *
FROM empleado
INNER JOIN departamento
ON empleado.IDDepartamento = departamento.IDDepartamento

Ejemplo de la sentencia INNER JOIN implcita:

SELECT *
FROM empleado, departamento
WHERE empleado.IDDepartamento = departamento.IDDepartamento

Otros ejemplos
Supongamos que queremos obtener todos los clientes que no tienen acciones.
Un LEFT JOIN no da los cliente que tienen y que no tienen acciones, para obtener solo los que
no tienen acciones agregamos al LEFT JOIN un WHERE accion is NULL
mysql> select nombre, telefono, accion, cantidad from clientes left join acciones on
clientes.cid=acciones.cid where accion is null;
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| jose | 111 | NULL | NULL |
| manuel | 333 | NULL | NULL |
+--------+----------+--------+----------+
2 rows in set (0.00 sec)

Para obtener aquellas tenencias de acciones que no tienen clientes, es similar al RIGHT JOIN
pero le agregamos un WHERE nombre is NULL

mysql> select nombre, telefono, accion, cantidad from clientes right join acciones on
clientes.cid=acciones.cid where nombre is null;
+--------+----------+--------+----------+
| nombre | telefono | accion | cantidad |
+--------+----------+--------+----------+
| NULL | NULL | FORD | 100 |
+--------+----------+--------+----------+
1 row in set (0.00 sec)