Oracle Database
Se une
Buscar..
Unirse a la cruz
Una CROSS JOIN realiza una unión entre dos tablas que no usa una cláusula de unión explícita y da como resultado el producto cartesiano de dos tablas. Un producto cartesiano significa que cada fila de una tabla se combina con cada fila de la segunda tabla en la unión. Por ejemplo, si TABLEA tiene 20 filas y TABLEB tiene 20 filas, el resultado sería 20*20 = 400 filas de salida.
Ejemplo:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
Esto también se puede escribir como:
SELECT *
FROM TABLEA, TABLEB;
Aquí hay un ejemplo de unión cruzada en SQL entre dos tablas:
Tabla de muestra: TABLEA
+-------+---------+
| VALUE | NAME |
+-------+---------+
| 1 | ONE |
| 2 | TWO |
+-------+---------+
Tabla de muestra: TABLEB
+-------+--------+
| VALUE | NAME |
+-------+--------+
| 3 | THREE |
| 4 | FOUR |
+-------+--------+
Ahora, si ejecuta la consulta:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
Salida:
+-------+--------+-------+--------+
| VALUE | NAME | VALUE | NAME |
+-------+--------+-------+--------+
| 1 | ONE | 3 | THREE |
| 1 | ONE | 4 | FOUR |
| 2 | TWO | 3 | THREE |
| 2 | TWO | 4 | FOUR |
+-------+--------+-------+--------+
Así es como ocurre la unión cruzada entre dos tablas: 
Más sobre Cross Join: documentación de Oracle
UNIR INTERNAMENTE
Un INNER JOIN es una operación JOIN que le permite especificar una cláusula de unión explícita.
Sintaxis
TableExpression [INNER] JOIN TableExpression {ON booleanExpression | Cláusula USING}
Puede especificar la cláusula de unión especificando ON con una expresión booleana.
El alcance de las expresiones en la cláusula ON incluye las tablas actuales y cualquier tabla en bloques de consulta externos al SELECT actual. En el siguiente ejemplo, la cláusula ON se refiere a las tablas actuales:
-- Join the EMP_ACT and EMPLOYEE tables
-- select all the columns from the EMP_ACT table and
-- add the employee's surname (LASTNAME) from the EMPLOYEE table
-- to each row of the result
SELECT SAMP.EMP_ACT.*, LASTNAME
FROM SAMP.EMP_ACT JOIN SAMP.EMPLOYEE
ON EMP_ACT.EMPNO = EMPLOYEE.EMPNO
-- Join the EMPLOYEE and DEPARTMENT tables,
-- select the employee number (EMPNO),
-- employee surname (LASTNAME),
-- department number (WORKDEPT in the EMPLOYEE table and DEPTNO in the
-- DEPARTMENT table)
-- and department name (DEPTNAME)
-- of all employees who were born (BIRTHDATE) earlier than 1930.
SELECT EMPNO, LASTNAME, WORKDEPT, DEPTNAME
FROM SAMP.EMPLOYEE JOIN SAMP.DEPARTMENT
ON WORKDEPT = DEPTNO
AND YEAR(BIRTHDATE) < 1930
-- Another example of "generating" new data values,
-- using a query which selects from a VALUES clause (which is an
-- alternate form of a fullselect).
-- This query shows how a table can be derived called "X"
-- having 2 columns "R1" and "R2" and 1 row of data
SELECT *
FROM (VALUES (3, 4), (1, 5), (2, 6))
AS VALUESTABLE1(C1, C2)
JOIN (VALUES (3, 2), (1, 2),
(0, 3)) AS VALUESTABLE2(c1, c2)
ON VALUESTABLE1.c1 = VALUESTABLE2.c1
-- This results in:
-- C1 |C2 |C1 |2
-- -----------------------------------------------
-- 3 |4 |3 |2
-- 1 |5 |1 |2
-- List every department with the employee number and
-- last name of the manager
SELECT DEPTNO, DEPTNAME, EMPNO, LASTNAME
FROM DEPARTMENT INNER JOIN EMPLOYEE
ON MGRNO = EMPNO
-- List every employee number and last name
-- with the employee number and last name of their manager
SELECT E.EMPNO, E.LASTNAME, M.EMPNO, M.LASTNAME
FROM EMPLOYEE E INNER JOIN
DEPARTMENT INNER JOIN EMPLOYEE M
ON MGRNO = M.EMPNO
ON E.WORKDEPT = DEPTNO
IZQUIERDA COMBINACIÓN EXTERNA
Una LEFT OUTER JOIN realiza una unión entre dos tablas que requiere una cláusula de unión explícita pero no excluye filas no coincidentes de la primera tabla.
Ejemplo:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP LEFT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
Aunque la sintaxis ANSI es la forma recomendada , es probable que se encuentre con una sintaxis heredada muy a menudo. El uso de (+) dentro de una condición determina qué lado de la ecuación debe considerarse como externo .
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP,
SCOTT.DEPT
WHERE
EMP.DEPTNO = DEPT.DEPTNO(+);
Aquí hay un ejemplo de la combinación externa izquierda entre dos tablas:
Tabla de muestra: EMPLEADO
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Tabla de muestra: DEPTO
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Ahora, si ejecuta la consulta:
SELECT
*
FROM
EMPLOYEE LEFT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Salida:
+-----------+---------+---------+--------------+
| NAME | DEPTNO | DEPTNO | DEPTNAME |
+-----------+---------+---------+--------------+
| F | 1 | 1 | ACCOUNTING |
| E | 1 | 1 | ACCOUNTING |
| B | 1 | 1 | ACCOUNTING |
| D | 2 | 2 | FINANCE |
| A | 2 | 2 | FINANCE |
| C | 3 | | |
| H | 4 | | |
| G | 4 | | |
+-----------+---------+---------+--------------+
JUSTE EXTERIOR DERECHO
A RIGHT OUTER JOIN realiza una unión entre dos tablas que requiere una cláusula de unión explícita pero no excluye filas no coincidentes de la segunda tabla.
Ejemplo:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP RIGHT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
Como se incluyen las filas no SCOTT.DEPT de SCOTT.DEPT , pero no se incluyen las filas no SCOTT.EMP de SCOTT.EMP , lo anterior es equivalente a la siguiente declaración que usa LEFT OUTER JOIN .
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.DEPT RIGHT OUTER JOIN SCOTT.EMP
ON DEPT.DEPTNO = EMP.DEPTNO;
Aquí hay un ejemplo de unión externa derecha entre dos tablas:
Tabla de muestra: EMPLEADO
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Tabla de muestra: DEPTO
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Ahora, si ejecuta la consulta:
SELECT
*
FROM
EMPLOYEE RIGHT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Salida:
+-----------+---------+---------+--------------+
| NAME | DEPTNO | DEPTNO | DEPTNAME |
+-----------+---------+---------+--------------+
| A | 2 | 2 | FINANCE |
| B | 1 | 1 | ACCOUNTING |
| D | 2 | 2 | FINANCE |
| E | 1 | 1 | ACCOUNTING |
| F | 1 | 1 | ACCOUNTING |
| | | 5 | MARKETING |
| | | 6 | HR |
+-----------+---------+---------+--------------+
La sintaxis de Oracle (+) equivalente para la consulta es:
SELECT *
FROM EMPLOYEE, DEPT
WHERE EMPLOYEE.DEPTNO(+) = DEPT.DEPTNO;
ÚNICAMENTE EN EL EXTERIOR
Un FULL OUTER JOIN realiza una unión entre dos tablas que requiere una cláusula de unión explícita pero no excluye filas no coincidentes en ninguna de las tablas. En otras palabras, devuelve todas las filas en cada tabla.
Ejemplo:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Aquí hay un ejemplo de Full Outer Join entre dos tablas:
Tabla de muestra: EMPLEADO
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Tabla de muestra: DEPTO
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Ahora, si ejecuta la consulta:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Salida
+-----------+---------+---------+--------------+
| NAME | DEPTNO | DEPTNO | DEPTNAME |
+-----------+---------+---------+--------------+
| A | 2 | 2 | FINANCE |
| B | 1 | 1 | ACCOUNTING |
| C | 3 | | |
| D | 2 | 2 | FINANCE |
| E | 1 | 1 | ACCOUNTING |
| F | 1 | 1 | ACCOUNTING |
| G | 4 | | |
| H | 4 | | |
| | | 6 | HR |
| | | 5 | MARKETING |
+-----------+---------+---------+--------------+
Aquí las columnas que no coinciden se han mantenido en NULL.
Aniquilar
Un antijoin devuelve filas desde el lado izquierdo del predicado para el que no hay filas correspondientes en el lado derecho del predicado. Devuelve las filas que no logran coincidir (NO EN) con la subconsulta en el lado derecho.
SELECT * FROM employees
WHERE department_id NOT IN
(SELECT department_id FROM departments
WHERE location_id = 1700)
ORDER BY last_name;
Aquí hay un ejemplo de Anti Join entre dos tablas:
Tabla de muestra: EMPLEADO
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Tabla de muestra: DEPTO
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Ahora, si ejecuta la consulta:
SELECT
*
FROM
EMPLOYEE WHERE DEPTNO NOT IN
(SELECT DEPTNO FROM DEPT);
Salida:
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| C | 3 |
| H | 4 |
| G | 4 |
+-----------+---------+
La salida muestra que solo las filas de la tabla EMPLOYEE, de las cuales DEPTNO no estaban presentes en la tabla DEPT.
SEMIJOIN
Se puede usar una consulta de semijoin, por ejemplo, para encontrar todos los departamentos con al menos un empleado cuyo salario exceda de 2500.
SELECT * FROM departments
WHERE EXISTS
(SELECT 1 FROM employees
WHERE departments.department_id = employees.department_id
AND employees.salary > 2500)
ORDER BY department_name;
Esto es más eficiente que las alternativas de unión completa, ya que la unión interna de los empleados y luego una cláusula donde se detalla que el salario debe ser superior a 2500 podría devolver el mismo departamento varias veces. Diga si el departamento de Bomberos tiene n empleados, todos con el salario 3000, select * from departments, employees con las inscripciones necesarias en las identificaciones y nuestra cláusula de dónde devolvería el departamento de Bomberos n veces.
UNIRSE
La operación JOIN realiza una unión entre dos tablas, excluyendo cualquier fila no coincidente de la primera tabla. Desde Oracle 9i adelante, la función JOIN es equivalente en función a la INNER JOIN . Esta operación requiere una cláusula de unión explícita, a diferencia de los operadores CROSS JOIN y NATURAL JOIN .
Ejemplo:
select t1.*,
t2.DeptId
from table_1 t1
join table_2 t2 on t2.DeptNo = t1.DeptNo
Documentación de Oracle:
Unirse natural
La unión natural no requiere una condición de unión explítica; construye uno basado en todos los campos con el mismo nombre en las tablas unidas.
create table tab1(id number, descr varchar2(100));
create table tab2(id number, descr varchar2(100));
insert into tab1 values(1, 'one');
insert into tab1 values(2, 'two');
insert into tab1 values(3, 'three');
insert into tab2 values(1, 'ONE');
insert into tab2 values(3, 'three');
La unión se realizará en los campos ID y DESCR, comunes a ambas tablas:
SQL> select *
2 from tab1
3 natural join
4 tab2;
ID DESCR
---------- ----------
3 three
Las columnas con nombres diferentes no se utilizarán en la condición de ÚNETE:
SQL> select *
2 from (select id as id, descr as descr1 from tab1)
3 natural join
4 (select id as id, descr as descr2 from tab2);
ID DESCR1 DESCR2
---------- ---------- ----------
1 one ONE
3 three three
Si las tablas unidas no tienen columnas comunes, se realizará una ÚNETE sin condiciones:
SQL> select *
2 from (select id as id1, descr as descr1 from tab1)
3 natural join
4 (select id as id2, descr as descr2 from tab2);
ID1 DESCR1 ID2 DESCR2
---------- ---------- ---------- ----------
1 one 1 ONE
2 two 1 ONE
3 three 1 ONE
1 one 3 three
2 two 3 three
3 three 3 three