Tutorial de Uniones en SQL

SQL Server es un sistema de gestión de bases de datos relacionales. Uno de los principios clave de la base de datos relacional es que los datos se almacenan en varias tablas.

Necesitaremos poder unir tablas para extraer los datos que necesitamos. Utilizamos las claves primary y foreign para unir tablas.

Clave primaria

Una clave primaria es una columna que se utiliza para identificar de forma única cada fila de una tabla. Esta unicidad puede conseguirse utilizando un entero secuencial como columna de identidad. O a veces, las columnas existentes contienen naturalmente valores únicos, y se pueden utilizar.

En el ejemplo siguiente, podemos ver las primeras filas de la tabla artist. Tiene dos columnas, artist_id, y name. La columna artist_id actúa como clave primaria de esta tabla, es una columna entera y cada valor es diferente.

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+

Ahora veamos la tabla album. ¿Puedes detectar la clave primaria? Sí, es la columna album_id. Es habitual que la clave primaria se denomine "nombre-tabla guión bajo id". Pero te habrás dado cuenta de que también hay una columna artist_id. Que también consta de números enteros y tiene el mismo nombre que la columna artist_id de la tabla de artistas. ¿Qué significa esto?

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+

Claves extranjeras

Pues bien, de la salida anterior se desprende que la artist_id de la tabla de artistas actúa como Foreign_key de la tabla de álbumes. La restricción FOREIGN KEY se utiliza para impedir acciones que destruyan enlaces entre tablas.

• artist tabla

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+

• album tabla

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+

Esto significa que cuando el artist_id de la tabla de álbumes coincide con el artist_id de la tabla de artistas, esas filas pueden enlazarse como un JOIN.

Unir Álbum y Artista

Las filas 1 y 4 de la tabla de artistas tienen un artist_id de 1. El artist_id 1 de la tabla de artistas es AC/DC. Así, cuando unimos las dos tablas, devolvemos los datos del álbum de la tabla álbum, y los datos del artista correspondiente de la tabla artista - unidos mediante el campo artist_id, que es común a ambas tablas.

Esto se conoce como unión inner.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;

+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------|

Unimos las tablas de álbumes y artistas haciendo coincidir el artist_id de la tabla de artistas con el artist_id de la tabla de álbumes.

Cuando selecciones columnas con el mismo nombre de tablas diferentes, debes calificar completamente el nombre de la columna. De lo contrario, SQL Server no sabrá de qué tabla SELECT debe extraer la columna.

Para calificar completamente una columna, tienes que anteponerle el nombre de la tabla correspondiente, seguido de un punto.

Sintaxis de la unión interna

Aquí tienes un ejemplo genérico para recordarte la sintaxis. Cuando seleccionamos las columnas relevantes de la tabla principal, table_A en este caso, a continuación seleccionamos cualquier columna adicional a la que queramos unirnos, que en este caso es table_B. A continuación, especificamos la unión utilizando las palabras clave INNER JOIN y ON, proporcionando las columnas clave necesarias de ambas tablas.

SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;

No utilizar un WHERE Cláusula

En este ejemplo, no especificamos una cláusula WHERE, por lo que devolvemos TODAS las combinaciones de TODAS las coincidencias entre las tablas de artistas y álbumes, de nuevo, basándonos en la columna artist_id, que es común a ambas.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;

+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+

Unión interna múltiple

También puedes unir más de dos tablas utilizando INNER JOINS. Sólo tienes que proporcionar un INNER JOIN adicional para cada combinación de tablas. En nuestro código siguiente, unimos las tablas A y B, y también B y C.

SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;

Para saber más sobre la unión de tablas, consulta este vídeo de nuestro curso Introducción a SQL Server.

Este contenido está tomado del curso Introducción a SQL Server de DataCamp, impartido por John MacKintosh.