Unión izquierda de SQL

Este artículo proporciona una descripción general de LEFT JOIN en SQL, así como algunos ejemplos básicos.

El LEFT JOIN , o LEFT OUTER JOIN , devuelve filas que tienen datos en la tabla de la izquierda (a la izquierda de JOIN palabra clave), incluso si no hay filas coincidentes en la tabla de la derecha.

Sintaxis

Usted especifica una combinación izquierda en el FROM cláusula. Puede usar el LEFT JOIN o LEFT OUTER JOIN sintaxis.

Usando LEFT JOIN sintaxis:

SELECT *
FROM Table1 LEFT JOIN Table2 
ON Table1.Column = Table2.Column;

Usando la LEFT OUTER JOIN sintaxis:

SELECT *
FROM Table1 LEFT OUTER JOIN Table2 
ON Table1.Column = Table2.Column;

Ambos hacen exactamente lo mismo. Es solo que el OUTER la palabra clave es opcional.

Ejemplos

Aquí hay algunos ejemplos para demostrar.

Datos de muestra

Primero, aquí están las tablas que usaremos para los ejemplos.

Los PetTypes tabla:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Las Pets tabla:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

Los Owners tabla:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
+-----------+-------------+------------+----------------+-------------------+

Tenga en cuenta que:

• El PetTypeId columna de Pets la tabla es una clave externa del PetTypeId de los PetTypes tabla (que es la clave principal de esa tabla).
• El OwnerId columna de Pets la tabla es una clave externa del OwnerId columna de los Owners mesa.

La consulta de unión izquierda

Este es un ejemplo de cómo realizar una combinación izquierda en dos de esas tablas.

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

La combinación izquierda hace que obtengamos un PetType valor que no se corresponde con un PetName . No hay conejos como mascotas. Pero la combinación izquierda causa Rabbit para ser devuelto, aunque no haya ninguna mascota en Pets tabla de ese tipo. Esto da como resultado un NULL valor en PetName columna contra Rabbit .

Esto solo sucedió porque Rabbit estaba en la tabla de la izquierda (es decir, a la izquierda de LEFT JOIN palabras clave). OK, mi formato lo hace más "arriba" que "izquierda", pero te haces una idea.

Esto es lo que sucede si cambiamos el orden de la tabla en nuestra consulta.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
LEFT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Esta vez Rabbits no fue devuelto. Eso es porque su tabla (PetTypes ) estaba en el lado derecho de la unión.

Tendríamos que cambiarlo a una unión derecha o una unión completa si quisiéramos Rabbits para ser devuelto usando este orden de mesa.

Unión izquierda en 3 tablas

Este es un ejemplo de cómo realizar una combinación izquierda en las tres tablas.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o LEFT JOIN Pets p
    ON p.OwnerId = o.OwnerId
LEFT JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+----------------+
| PetName   | PetType   | PetOwner       |
|-----------+-----------+----------------|
| Tweet     | Bird      | Homer Connery  |
| Scratch   | Cat       | Bart Pitt      |
| Bark      | Dog       | Bart Pitt      |
| Fluffy    | Cat       | Nancy Simpson  |
| Fetch     | Dog       | Nancy Simpson  |
| Wag       | Dog       | Nancy Simpson  |
| Fluffy    | Dog       | Boris Trump    |
| Meow      | Cat       | Boris Trump    |
| NULL      | NULL      | Woody Eastwood |
+-----------+-----------+----------------+
(9 rows affected)

Esta vez tenemos un dueño de mascota que no tiene mascota.

Podríamos volver a cambiar el orden de las mesas y obtendríamos un resultado diferente.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt LEFT JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
LEFT JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

Resultado:

+-----------+-----------+---------------+
| PetName   | PetType   | PetOwner      |
|-----------+-----------+---------------|
| Tweet     | Bird      | Homer Connery |
| Fluffy    | Cat       | Nancy Simpson |
| Scratch   | Cat       | Bart Pitt     |
| Meow      | Cat       | Boris Trump   |
| Fetch     | Dog       | Nancy Simpson |
| Wag       | Dog       | Nancy Simpson |
| Fluffy    | Dog       | Boris Trump   |
| Bark      | Dog       | Bart Pitt     |
| NULL      | Rabbit    |               |
+-----------+-----------+---------------+
(9 rows affected)

Esta vez obtuvimos el tipo de mascota extra (Rabbit ), pero no el propietario adicional.

Si te preguntas por qué el último PetOwner no es NULL (como el último PetName is), es porque es el resultado de una concatenación de cadenas. Usé T-SQL CONCAT() función para concatenar el nombre y apellido del propietario.