Unión derecha de SQL

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

También conocido como RIGHT OUTER JOIN , la RIGHT JOIN devuelve filas que tienen datos en la tabla de la derecha (a la derecha de JOIN palabra clave), incluso si no hay filas coincidentes en la tabla de la izquierda.

Sintaxis

Especificas una unión derecha en el FROM cláusula. Puede utilizar RIGHT JOIN o RIGHT OUTER JOIN sintaxis.

Usando RIGHT JOIN sintaxis:

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

Uso de la RIGHT OUTER JOIN sintaxis:

SELECT *
FROM Table1 RIGHT 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 Correcta

Este es un ejemplo de cómo realizar una unión a la derecha en dos de esas tablas.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
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 unión correcta hace que obtengamos un PetType valor que no se corresponde con un PetName . Específicamente, no hay conejos como mascotas. Pero la unión correcta provoca 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 derecha (es decir, a la derecha de RIGHT JOIN palabras clave).

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

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
RIGHT JOIN Pets p
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 izquierdo de la unión.

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

Unión derecha en 3 tablas

Este es un ejemplo de cómo realizar una unión a la derecha en las tres tablas.

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

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 Pets p RIGHT JOIN Owners o 
    ON p.OwnerId = o.OwnerId
RIGHT JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId;

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.