{"id":11230,"date":"2024-02-18T11:32:33","date_gmt":"2024-02-18T10:32:33","guid":{"rendered":"https:\/\/www.palentino.es\/blog\/?p=11230"},"modified":"2024-02-18T11:32:44","modified_gmt":"2024-02-18T10:32:44","slug":"relaciones-disponibles-entre-tablas-sql-en-los-principales-gestores-de-bases-de-datos-sql-join","status":"publish","type":"post","link":"https:\/\/www.palentino.es\/blog\/relaciones-disponibles-entre-tablas-sql-en-los-principales-gestores-de-bases-de-datos-sql-join\/","title":{"rendered":"Relaciones disponibles entre tablas SQL en los principales gestores de Bases de datos. #sql #join"},"content":{"rendered":"

Las relaciones entre tablas en una base de datos SQL son fundamentales para organizar y acceder a los datos de manera eficiente. Estas relaciones se establecen mediante el uso de claves primarias<\/strong> (Primary Keys, PK) y claves for\u00e1neas<\/strong> (Foreign Keys, FK), permitiendo modelar las interacciones entre los diferentes conjuntos de datos.<\/p>\n

Existen tres tipos principales de relaciones: Uno a Uno (1:1), Uno a Muchos (1:N) y Muchos a Muchos (M:N).<\/p>\n

Veamos cada una en detalle:\"\"<\/a><\/p>\n

 <\/p>\n

Las relaciones entre tablas en una base de datos SQL son fundamentales para organizar y acceder a los datos de manera eficiente. Estas relaciones se establecen mediante el uso de claves primarias (Primary Keys, PK) y claves for\u00e1neas (Foreign Keys, FK), permitiendo modelar las interacciones entre los diferentes conjuntos de datos. Existen tres tipos principales de relaciones: Uno a Uno (1:1), Uno a Muchos (1:N) y Muchos a Muchos (M:N). Veamos cada una en detalle:<\/p>\n

<\/p>\n

1. Relaci\u00f3n Uno a Uno (1:1)<\/h3>\n

En una relaci\u00f3n 1:1, cada fila en una tabla est\u00e1 relacionada con no m\u00e1s de una fila en otra tabla. Este tipo de relaci\u00f3n se utiliza cuando se quiere separar la informaci\u00f3n por razones de dise\u00f1o o seguridad, pero cada elemento de una tabla solo puede estar asociado con un \u00fanico elemento de la otra tabla.<\/p>\n

Ejemplo<\/strong>: Considera una tabla Usuarios donde cada usuario tiene una \u00fanica direcci\u00f3n. Se podr\u00eda tener una tabla Direcciones donde cada direcci\u00f3n est\u00e1 asociada con un solo usuario. La clave primaria de Usuarios se utiliza como clave for\u00e1nea en Direcciones.<\/p>\n

CREATE TABLE Usuarios (\r\nUsuarioID INT PRIMARY KEY,\r\nNombre VARCHAR(100)\r\n);\r\n\r\nCREATE TABLE Direcciones (\r\nDireccionID INT PRIMARY KEY,\r\nUsuarioID INT UNIQUE,\r\nDireccion VARCHAR(255),\r\nCONSTRAINT FK_UsuarioDireccion FOREIGN KEY (UsuarioID)\r\nREFERENCES Usuarios(UsuarioID)\r\n);\r\n<\/pre>\n
La restricci\u00f3n<\/p>\n
1
<\/div><\/td>
UNIQUE<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
en<\/p>\n
1
<\/div><\/td>
UsuarioID<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
de la tabla<\/p>\n
1
<\/div><\/td>
Direcciones<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
asegura la relaci\u00f3n 1:1.<\/p>\n
2. Relaci\u00f3n Uno a Muchos (1:N)<\/h3>\n
La relaci\u00f3n 1:N es la m\u00e1s com\u00fan en las bases de datos relacionales. En este caso, una fila en la tabla principal puede estar relacionada con una o muchas filas en la tabla relacionada, pero una fila en la tabla relacionada solo puede estar asociada con una fila en la tabla principal.<\/p>\n
Ejemplo<\/strong>: Una tabla<\/p>\n
1
<\/div><\/td>
Profesores<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
y una tabla<\/p>\n
1
<\/div><\/td>
Cursos<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
. Un profesor puede ense\u00f1ar varios cursos, pero cada curso es ense\u00f1ado por un solo profesor.<\/p>\n
CREATE TABLE Profesores (\r\nProfesorID INT PRIMARY KEY,\r\nNombre VARCHAR(100)\r\n);\r\n\r\nCREATE TABLE Cursos (\r\nCursoID INT PRIMARY KEY,\r\nProfesorID INT,\r\nNombreCurso VARCHAR(100),\r\nCONSTRAINT FK_CursoProfesor FOREIGN KEY (ProfesorID)\r\nREFERENCES Profesores(ProfesorID)\r\n);\r\n<\/\r\n<\/pre>\n
En este caso,<\/p>\n
1
<\/div><\/td>
ProfesorID<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
en<\/p>\n
1
<\/div><\/td>
Cursos<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
es una clave for\u00e1nea que referencia<\/p>\n
1
<\/div><\/td>
ProfesorID<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
en<\/p>\n
1
<\/div><\/td>
Profesores<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
.<\/p>\n
3. Relaci\u00f3n Muchos a Muchos (M:N)<\/h3>\n
Una relaci\u00f3n M:N permite que varias filas en una tabla est\u00e9n asociadas con varias filas en otra tabla. Esta relaci\u00f3n se implementa mediante una tabla intermedia (tambi\u00e9n llamada tabla de uni\u00f3n o tabla de asociaci\u00f3n) que contiene claves for\u00e1neas que apuntan a las claves primarias de las tablas relacionadas. Ejemplo<\/strong>: Una tabla<\/p>\n
1
<\/div><\/td>
Estudiantes<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
y una tabla<\/p>\n
1
<\/div><\/td>
Cursos<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
. Un estudiante puede inscribirse en muchos cursos, y un curso puede ser elegido por muchos estudiantes.<\/p>\n
CREATE TABLE Estudiantes (\r\nEstudianteID INT PRIMARY KEY,\r\nNombre VARCHAR(100)\r\n);\r\n\r\nCREATE TABLE Cursos (\r\nCursoID INT PRIMARY KEY,\r\nNombreCurso VARCHAR(100)\r\n);\r\n\r\nCREATE TABLE Inscripciones (\r\nEstudianteID INT,\r\nCursoID INT,\r\nFechaInscripcion DATE,\r\nPRIMARY KEY (EstudianteID, CursoID),\r\nCONSTRAINT FK_InscripcionEstudiante FOREIGN KEY (EstudianteID)\r\nREFERENCES Estudiantes(EstudianteID),\r\nCONSTRAINT FK_InscripcionCurso FOREIGN KEY (CursoID)\r\nREFERENCES Cursos(CursoID)\r\n);\r\n<\/pre>\n
 <\/p>\n
En `Inscripciones`, las columnas `EstudianteID` y `CursoID` sirven como claves for\u00e1neas que juntas forman una clave primaria compuesta, estableciendo as\u00ed la relaci\u00f3n M:N entre `Estudiantes` y `Cursos`.<\/p>\n
Estos tipos de relaciones entre tablas son fundamentales para el dise\u00f1o y la normalizaci\u00f3n de bases de datos, permitiendo modelar relaciones complejas entre los datos de manera eficiente y flexible.<\/p>\n
 <\/p>\n
En SQL, los JOINs son utilizados para combinar filas de dos o m\u00e1s tablas, bas\u00e1ndose en una columna relacionada entre ellas. Los tipos principales de JOINs son: INNER JOIN, LEFT JOIN (LEFT OUTER JOIN), RIGHT JOIN (RIGHT OUTER JOIN) y FULL OUTER JOIN. Cada uno de estos tipos de JOIN sirve para un prop\u00f3sito espec\u00edfico en la consulta de datos relacionales. Aqu\u00ed te explico c\u00f3mo funcionan:<\/p>\n
1. INNER JOIN<\/h3>\n
El<\/p>\n
1
<\/div><\/td>
INNER JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
selecciona registros que tienen valores coincidentes en ambas tablas. Es decir, devuelve solo las filas que tienen al menos una coincidencia en la otra tabla. Si no hay coincidencia, las filas no se incluyen en el resultado.<\/p>\n
SELECT empleados.nombre, departamentos.nombre_departamento\r\nFROM empleados\r\nINNER JOIN departamentos ON empleados.departamento_id = departamentos.id;\r\n<\/pre>\n
 <\/p>\n
Este ejemplo muestra los nombres de los empleados junto con los nombres de sus departamentos, pero solo incluye a aquellos empleados que est\u00e1n asignados a un departamento.<\/p>\n
2. LEFT JOIN (o LEFT OUTER JOIN)<\/h3>\n
El<\/p>\n
1
<\/div><\/td>
LEFT JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
devuelve todas las filas de la tabla izquierda (la primera tabla), y las filas coincidentes de la tabla derecha (la segunda tabla). Las filas que no tienen coincidencia en la tabla derecha tendr\u00e1n<\/p>\n
1
<\/div><\/td>
NULL<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
en las columnas de la tabla derecha.<\/p>\n
Ejemplo:<\/strong><\/p>\n
SELECT empleados.nombre, departamentos.nombre_departamento\r\nFROM empleados\r\nLEFT JOIN departamentos ON empleados.departamento_id = departamentos.id;\r\n<\/pre>\n
Aqu\u00ed, se obtienen todos los empleados, incluidos aquellos que no est\u00e1n asignados a ning\u00fan departamento. Para estos \u00faltimos, el<\/p>\n
1
<\/div><\/td>
nombre_departamento<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
ser\u00e1<\/p>\n
1
<\/div><\/td>
NULL<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
.<\/p>\n
3. RIGHT JOIN (o RIGHT OUTER JOIN)<\/h3>\n
El<\/p>\n
1
<\/div><\/td>
RIGHT JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
funciona de manera opuesta al<\/p>\n
1
<\/div><\/td>
LEFT JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
: devuelve todas las filas de la tabla derecha, y las filas coincidentes de la tabla izquierda. Si no hay coincidencia en la tabla izquierda, el resultado tendr\u00e1<\/p>\n
1
<\/div><\/td>
NULL<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
en las columnas de la tabla izquierda.<\/p>\n
Ejemplo:<\/strong><\/p>\n
SELECT empleados.nombre, departamentos.nombre_departamento\r\nFROM empleados\r\nRIGHT JOIN departamentos ON empleados.departamento_id = departamentos.id;\r\n<\/pre>\n
 <\/p>\n
4. FULL OUTER JOIN<\/h3>\n
El<\/p>\n
1
<\/div><\/td>
FULL OUTER JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
combina los resultados de<\/p>\n
1
<\/div><\/td>
LEFT JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
y<\/p>\n
1
<\/div><\/td>
RIGHT JOIN<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
. Devuelve todas las filas cuando hay una coincidencia en una de las tablas. Por lo tanto, muestra todas las filas de ambas tablas, con<\/p>\n
1
<\/div><\/td>
NULL<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
en las columnas de una tabla cuando no hay coincidencias en la otra tabla.<\/p>\n
Ejemplo:<\/strong><\/p>\n
SELECT empleados.nombre, departamentos.nombre_departamento\r\nFROM empleados\r\nFULL OUTER JOIN departamentos ON empleados.departamento_id = departamentos.id;\r\n<\/pre>\n
 <\/p>\n
Variaciones en JOINS<\/h1>\n
\n
\n
\n
\n
\n
\n
\n
\n
A los tipos de JOINs en SQL habituales, se les pueden a\u00f1adir otros y se pueden resumir en las siguientes categor\u00edas, cada una con su prop\u00f3sito espec\u00edfico para combinar filas de dos o m\u00e1s tablas:<\/p>\n
    \n
  1. INNER JOIN<\/strong>: Devuelve filas cuando hay al menos una coincidencia en ambas tablas. Si no hay coincidencia, las filas no se muestran.<\/li>\n
  2. LEFT JOIN (o LEFT OUTER JOIN)<\/strong>: Devuelve todas las filas de la tabla izquierda, y las filas coincidentes de la tabla derecha. Las filas de la tabla izquierda que no tienen coincidencias en la tabla derecha se muestran con valores NULL en las columnas de la tabla derecha.<\/li>\n
  3. RIGHT JOIN (o RIGHT OUTER JOIN)<\/strong>: Devuelve todas las filas de la tabla derecha, y las filas coincidentes de la tabla izquierda. Las filas de la tabla derecha que no tienen coincidencias en la tabla izquierda se muestran con valores NULL en las columnas de la tabla izquierda.<\/li>\n
  4. FULL OUTER JOIN<\/strong>: Combina los resultados de LEFT JOIN y RIGHT JOIN. Devuelve todas las filas cuando hay una coincidencia en una de las tablas. Las filas que no tienen coincidencias en la otra tabla se muestran con valores NULL en las columnas de la tabla que falta.<\/li>\n
  5. CROSS JOIN<\/strong>: Produce el producto cartesiano de las dos tablas involucradas, combinando cada fila de la primera tabla con todas las filas de la segunda tabla.<\/li>\n
  6. SELF JOIN<\/strong>: No es un tipo de JOIN espec\u00edfico, sino una t\u00e9cnica que implica unir una tabla consigo misma, trat\u00e1ndola como si fueran dos tablas separadas.<\/li>\n
  7. NATURAL JOIN<\/strong>: Realiza un INNER JOIN autom\u00e1ticamente basado en columnas con el mismo nombre y tipo en ambas tablas. No es recomendable debido a su dependencia de la coincidencia de nombres de columna, lo que puede llevar a resultados inesperados.<\/li>\n<\/ol>\n
    Adem\u00e1s de estos tipos principales, hay variaciones y t\u00e9cnicas espec\u00edficas como el uso de las cl\u00e1usulas<\/p>\n
    1
    <\/div><\/td>
    USING()<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
    y<\/p>\n
    1
    <\/div><\/td>
    ON<\/div><\/td><\/tr><\/tbody><\/table><\/div>\n
    para especificar las condiciones de uni\u00f3n, que pueden simplificar o ajustar la sintaxis y el comportamiento de los JOINs.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    Aunque los principales (INNER, LEFT, RIGHT, FULL OUTER, CROSS, y NATURAL JOIN) cubren la mayor\u00eda de las necesidades, aqu\u00ed te presento algunas extensiones y conceptos relacionados que, dependiendo del sistema de gesti\u00f3n de bases de datos (DBMS), pueden ofrecer funcionalidades adicionales o simplificar ciertas operaciones:<\/p>\n
    1. JOINs Condicionales<\/h3>\n
    No es un tipo de JOIN en s\u00ed, pero puedes escribir consultas que implementen l\u00f3gica condicional dentro de la cl\u00e1usula ON o WHERE para realizar JOINs basados en condiciones m\u00e1s complejas que simples equivalencias.<\/p>\n
    2. JOINs Exclusivos<\/h3>\n
    Otra t\u00e9cnica, no un tipo espec\u00edfico de JOIN, que permite seleccionar filas que solo existen en una de las tablas y no en la otra. Esto se puede lograr usando LEFT JOIN o RIGHT JOIN combinado con una cl\u00e1usula WHERE que filtra las filas con NULL en la tabla unida.<\/p>\n
    3. OUTER APPLY y CROSS APPLY<\/h3>\n
    Espec\u00edficos de SQL Server, estos operadores se parecen a los JOINs pero permiten unir una tabla a una funci\u00f3n de tabla valorada que toma columnas de la fila como argumentos en cada fila de la tabla izquierda (en el caso de OUTER APPLY) o realiza un producto cartesiano similar a CROSS JOIN con CROSS APPLY.<\/p>\n
    4. LATERAL JOIN (o simplemente LATERAL)<\/h3>\n
    Disponible en PostgreSQL y otros sistemas de bases de datos, LATERAL permite que una subconsulta en la cl\u00e1usula FROM haga referencia a columnas de tablas que aparecen antes de ella en la cl\u00e1usula FROM. Esto es \u00fatil para realizar operaciones que dependen de cada fila de la tabla precedente, similar en esp\u00edritu a CROSS APPLY y OUTER APPLY en SQL Server.<\/p>\n
    5. HASH JOIN, MERGE JOIN, y NESTED LOOP JOIN<\/h3>\n
    Estos son m\u00e1s sobre c\u00f3mo el DBMS ejecuta los JOINs bajo el cap\u00f3 en lugar de ser tipos de JOIN que un desarrollador especificar\u00eda en una consulta. Sin embargo, algunos DBMS permiten sugerencias (hints) que pueden influir en la elecci\u00f3n del algoritmo de JOIN:<\/p>\n