Explicación de autouniones

No entiendo la necesidad de autouniones. ¿Alguien puede explicarme por favor?

Un ejemplo sencillo sería muy útil.

Puede ver la autounión como dos tablas idénticas. Pero en la normalización, no puede crear dos copias de la tabla, por lo que simplemente simula tener dos tablas con autounión.

Suponga que tiene dos tablas:

Mesa emp1

Id Name Boss_id            
1   ABC   3                   
2   DEF   1                   
3   XYZ   2                   

Mesa emp2

Id Name Boss_id            
1   ABC   3                   
2   DEF   1                   
3   XYZ   2                   

Ahora, si desea obtener el nombre de cada empleado con los nombres de su jefe:

select c1.Name , c2.Name As Boss
from emp1 c1
    inner join emp2 c2 on c1.Boss_id = c2.Id

Que dará como resultado la siguiente tabla:

Name  Boss
ABC   XYZ
DEF   ABC
XYZ   DEF

Es bastante común cuando tienes una tabla que hace referencia a sí misma. Ejemplo: una tabla de empleados donde todos los empleados pueden tener un gerente y desea enumerar todos los empleados y el nombre de su gerente.

SELECT e.name, m.name
FROM employees e LEFT OUTER JOIN employees m
ON e.manager = m.id

Una autocombinación es una combinación de una tabla consigo misma.

Un caso de uso común es cuando la tabla almacena entidades (registros) que tienen una relación jerárquica entre ellos . Por ejemplo una tabla que contiene información de la persona (Nombre, Fecha de nacimiento, Dirección ...) y que incluye una columna donde se incluye el ID del Padre (y / o de la madre). Luego, con una pequeña consulta como

SELECT Child.ID, Child.Name, Child.PhoneNumber, Father.Name, Father.PhoneNumber
FROM myTableOfPersons As Child
LEFT OUTER JOIN  myTableOfPersons As Father ON Child.FatherId = Father.ID
WHERE Child.City = 'Chicago'  -- Or some other condition or none

podemos obtener información sobre el niño y el padre (y la madre, con una segunda unión, etc. e incluso los abuelos, etc.) en la misma consulta.

Digamos que tienes una mesa users, configurada así:

• ID de usuario
• nombre de usuario
• ID del administrador del usuario

En esta situación, si se quería sacar tanto la información del usuario y la información del gerente en una consulta, es posible hacer esto:

SELECT users.user_id, users.user_name, managers.user_id AS manager_id, managers.user_name AS manager_name INNER JOIN users AS manager ON users.manager_id=manager.user_id

Son útiles si su tabla es autorreferencial. Por ejemplo, para una tabla de páginas, cada página puede tener un enlace nexty previous. Estos serían los ID de otras páginas de la misma tabla. Si en algún momento desea obtener un triple de páginas sucesivas, haría dos autouniones en las columnas nexty previouscon la misma idcolumna de la tabla .

Imagine una tabla llamada Employeecomo se describe a continuación. Todos los empleados tienen un gerente que también es un empleado (tal vez excepto el CEO, cuyo manager_id sería nulo)

Table (Employee): 

int id,
varchar name,
int manager_id

A continuación, puede utilizar la siguiente selección para encontrar a todos los empleados y sus gerentes:

select e1.name, e2.name as ManagerName
from Employee e1, Employee e2 where
where e1.manager_id = e2.id

Sin la capacidad de una tabla para hacer referencia a sí misma, tendríamos que crear tantas tablas para niveles de jerarquía como la cantidad de capas en la jerarquía. Pero dado que esa funcionalidad está disponible, usted une la tabla consigo misma y sql la trata como dos tablas separadas, por lo que todo se almacena correctamente en un solo lugar.

Aparte de las respuestas mencionadas anteriormente (que están muy bien explicadas), me gustaría agregar un ejemplo para que se pueda mostrar fácilmente el uso de Self Join. Suponga que tiene una tabla llamada CLIENTES que tiene los siguientes atributos: CustomerID, CustomerName, ContactName, City, Country. Ahora desea enumerar todos los que son de la "misma ciudad". Tendrás que pensar en una réplica de esta mesa para que podamos unirlos sobre la base de CITY. La consulta a continuación mostrará claramente lo que significa:

SELECT A.CustomerName AS CustomerName1, B.CustomerName AS CustomerName2, 
A.City
FROM Customers A, Customers B
WHERE A.CustomerID <> B.CustomerID
AND A.City = B.City 
ORDER BY A.City;

Aquí hay muchas respuestas correctas, pero hay una variación que es igualmente correcta. Puede colocar sus condiciones de combinación en la declaración de combinación en lugar de la cláusula WHERE.

SELECT e1.emp_id AS 'Emp_ID'
  , e1.emp_name AS 'Emp_Name'
  , e2.emp_id AS 'Manager_ID'
  , e2.emp_name AS 'Manager_Name'
FROM Employee e1 RIGHT JOIN Employee e2 ON e1.emp_id = e2.emp_id

Tenga en cuenta que a veces desea e1.manager_id> e2.id

La ventaja de conocer ambos escenarios es que a veces tiene un montón de condiciones WHERE o JOIN y desea colocar sus condiciones de autounión en la otra cláusula para mantener su código legible.

Nadie abordó qué sucede cuando un empleado no tiene un gerente. ¿Eh? No se incluyen en el conjunto de resultados. ¿Qué sucede si desea incluir empleados que no tienen gerentes pero no desea que se devuelvan combinaciones incorrectas?

Prueba este cachorro;

SELECT e1.emp_id AS 'Emp_ID'
   , e1.emp_name AS 'Emp_Name'
   , e2.emp_id AS 'Manager_ID'
   , e2.emp_name AS 'Manager_Name'
FROM Employee e1 LEFT JOIN Employee e2 
   ON e1.emp_id = e2.emp_id
   AND e1.emp_name = e2.emp_name
   AND e1.every_other_matching_column = e2.every_other_matching_column

Un caso de uso es la verificación de registros duplicados en una base de datos.

SELECT A.Id FROM My_Bookings A, My_Bookings B
WHERE A.Name = B.Name
AND A.Date = B.Date
AND A.Id != B.Id

La autounión es útil cuando tiene que evaluar los datos de la tabla consigo misma. Lo que significa que correlacionará las filas de la misma tabla.

Syntax: SELECT * FROM TABLE t1, TABLE t2 WHERE t1.columnName = t2.columnName

Por ejemplo, queremos encontrar los nombres de los empleados cuya designación inicial es igual a la designación actual. Podemos resolver esto usando self join de la siguiente manera.

SELECT NAME FROM Employee e1, Employee e2 WHERE e1.intialDesignationId = e2.currentDesignationId

Es el equivalente en la base de datos de una lista / árbol vinculado, donde una fila contiene una referencia de alguna manera a otra fila.

Aquí está la explicación de la autounión en términos sencillos. La autounión no es un tipo diferente de combinación. Si ha entendido otros tipos de combinaciones (internas, externas y cruzadas), la autocompensación debería ser sencilla. En INNER, OUTER y CROSS JOINS, se une a 2 o más mesas diferentes. Sin embargo, en self join te unes a la misma mesa con itslef. Aquí, no tenemos 2 tablas diferentes, pero tratamos la misma tabla como una tabla diferente usando alias de tabla. Si esto aún no está claro, recomendaría ver los siguientes videos de YouTube.

Self Join con un ejemplo