Combinación interna de SQL

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

SQL INNER JOIN devuelve filas cuando hay al menos una fila en ambas tablas que coincide con la condición de unión. Descarta filas no coincidentes de ambas tablas. Este es el tipo de unión predeterminado.

Sintaxis

Hay dos formas de especificar una unión interna:en el FROM cláusula (utilizando la cláusula INNER JOIN sintaxis), o usando el WHERE cláusula.

Para especificar una combinación interna en FROM cláusula:

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

Para especificar una combinación interna en WHERE cláusula:

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

A continuación se muestran ejemplos de cada uno.

Ejemplos

Aquí tenemos ejemplos de cada método para especificar una combinación interna.

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              |
+-----------+-------------+------------+----------------+-------------------+

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.

Ejemplo usando la sintaxis INNER JOIN

Aquí hay un ejemplo básico de cómo especificar una combinación interna usando INNER JOIN sintaxis.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p INNER 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)

Para especificar una combinación interna en FROM cláusula, usamos INNER JOIN . También usamos el ON palabra clave para definir el predicado que se evaluará para cada par de filas unidas.

Independientemente del tipo de combinación, calificamos los nombres de nuestras columnas con los nombres de las tablas. La razón por la que hacemos esto es para evitar cualquier ambigüedad con respecto a los nombres de las columnas entre las tablas. Ambas tablas pueden tener columnas con el mismo nombre (como en nuestro ejemplo) y, en tales casos, el DBMS no sabrá a qué columna se refiere. Prefijar los nombres de las columnas con sus nombres de tabla asegura que está haciendo referencia a la columna correcta y evita cualquier error que pueda resultar de cualquier ambigüedad sobre a qué columna se está refiriendo.

En este ejemplo, ambas tablas tienen un PetTypeId columna. Las Pets.PetTypeId la columna es una clave externa a PetTypes.PetTypeId columna, que es la clave principal para esa tabla.

En este ejemplo, podemos ver que se devuelven todas las mascotas, pero no todos los tipos de mascotas. No hay conejos en Pets tabla, y así los Rabbits no se devuelve el tipo de mascota.

La razón por la que los Rabbits type no se devuelve porque INNER JOIN solo devuelve filas cuando hay al menos una fila en ambas tablas que coincide con la condición de combinación. En este caso, Rabbits está solo en una tabla (los PetTypes tabla).

El tipo de unión es opcional

Tenga en cuenta que el tipo de combinación es opcional. Por lo tanto, la mayoría (si no todos) los DBMS le permiten omitir el INNER palabra clave. Cuando omite esto (es decir, solo especifica JOIN ), se supone que es una combinación interna.

Por lo tanto, podríamos reescribir el ejemplo anterior a esto:

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

Formateo

Al igual que con cualquier instrucción SQL, puede usar espacios en blanco y sangrías, etc. para formatear sus consultas.

Por ejemplo, el FROM la cláusula puede estar en una línea completa si lo prefiere:

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

Cuando escribe tablas más grandes que unen varias tablas, la sangría puede ayudar mucho.

Ejemplo usando la Cláusula WHERE

La unión anterior también se puede denominar equi-unión . Una unión equitativa es una unión que contiene solo comparaciones de igualdad en el predicado de unión.

Aquí hay un ejemplo de cómo especificar una combinación interna usando WHERE cláusula:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE 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)

Esto devolvió el mismo resultado que el ejemplo anterior.

Aquí, simplemente proporcionamos una lista separada por comas de las tablas, y luego un WHERE condición. Si hubiéramos omitido el WHERE condición, habríamos terminado con un CROSS JOIN .

Muchos principiantes encuentran la sintaxis anterior mucho más fácil de entender que INNER JOIN sintaxis. Siéntase libre de usar esta sintaxis si lo prefiere, sin embargo, tenga en cuenta que la mayoría de los profesionales de SQL prefieren usar INNER JOIN sintaxis del ejemplo anterior..

Unión interna en 3 tablas

Este es un ejemplo de cómo realizar una unión interna en 3 tablas.

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

Resultado:

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

En este ejemplo, trajimos los Owners table en la mezcla porque necesitábamos esta consulta para devolver información sobre el propietario.

Para usar una tercera tabla, todo lo que hicimos fue agregar otro INNER JOIN... ON argumento junto con los detalles relevantes de la tabla/columna.

En este caso, utilicé CONCAT() de T-SQL función para concatenar dos columnas, pero esto es irrelevante para la unión.